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;
}
static gdb_sNode *
node (
net_sMessage *mp
)
{
pwr_tStatus sts;
gdb_sNode *np;
if (mp->nid == pwr_cNNodeId) {
errh_Error("Message from pwr_cNNodeId received");
return NULL;
}
gdb_ScopeLock {
np = hash_Search(&sts, gdbroot->nid_ht, &mp->nid);
} gdb_ScopeUnlock;
if (np == NULL) {
errh_Error("Message about unknown node: (%s) received\n",
cdh_NodeIdToString(NULL, mp->nid, 0, 0));
return NULL;
}
return np;
}
static void *
receive (
qcom_sQid *qid,
qcom_sGet *get
)
{
pwr_tStatus sts;
void *mp;
for (;;) {
get->data = NULL;
/* Loop until receiving a valid message. */
mp = qcom_Get(&sts, &qcom_cQnacp, get, qcom_cTmoEternal);
if (mp == NULL) {
errh_Error("qcom_Get, %m", sts);
continue;
}
if (get->type.b == qcom_eBtype_event) {
event(get);
qcom_Free(&sts, mp);
continue;
}
else if (get->type.b != net_cMsgClass) {
errh_Error("Received bad message, type: <%d>, subtype: <%d>", get->type.b, get->type.s);
qcom_Free(&sts, mp);
continue;
}
return mp;
}
}
static pwr_tBoolean
checkQ (
pool_sHead *php,
pool_sQlink *item
)
{
pool_sQlink *link;
if (item == NULL) {
errh_Error("checkQ in pool: %s, item == NULL", php->gphp->name);
return NO;
}
if (item->self == pool_cNRef) {
errh_Error("checkQ in pool: %s, item->self == pool_cNRef, item: %u", php->gphp->name, item);
return NO;
}
link = pool_Address(NULL, php, item->self);
if (item != link) {
errh_Error("checkQ in pool: %s, item != pool_Address(NULL, php, item->self),\n item: %u != %u",
php->gphp->name, item, link);
return NO;
}
return YES;
#if 0
return item == pool_Address(NULL, php, item->self);
#endif
}
static void
create_thread (
plc_sThread *tp,
plc_sProctbl *ptp,
plc_sProcess *pp
)
{
pwr_tStatus sts;
long int phase;
tp->aref.Objid = ptp->thread;
tp->init = ptp->init;
tp->exec = ptp->exec;
tp->first_scan = 1;
tp->PlcThread = pwrb_PlcThread_Init(&sts, tp);
tp->csup_lh = csup_Init(&sts, ptp->thread, tp->f_scan_time);
tp->i_scan_time = tp->f_scan_time * 1000.0 + 0.5;
time_FloatToD(&tp->scan_time, tp->f_scan_time);
tp->pp = pp;
plc_inittimer(tp);
tp->exit = FALSE;
link_io_copy_areas(tp);
que_Create(&sts, &tp->q_in);
que_Create(&sts, &tp->q_out);
sts = gdh_ObjidToName(ptp->thread, tp->name, sizeof(tp->name), cdh_mNName);
if (EVEN(sts)) {
errh_Error("Get name of thread object %s, %m", cdh_ObjidToString(NULL, ptp->thread, 1), sts);
return;
}
sts = gdh_ObjidToPointer(ptp->thread, (void *)&tp->PlcThread);
if (EVEN(sts)) {
errh_Error("Direct link to thread object \"%s\", %m", tp->name, sts);
return;
}
#if defined OS_LYNX && USE_RT_TIMER
sem_init(&tp->ScanSem, 0, 0);
tp->ScanMultiple = tp->i_scan_time / (CLK_TCK/1000);
tp->IntervalCount = tp->ScanMultiple;
#endif
sts = thread_Create(&tp->tid, tp->name, (void *(*)())&plc_thread, tp);
if (EVEN(sts)) {
errh_Error("Creating thread \"%s\", %m", tp->name, sts);
return;
}
/* Wait for thread to initialize. */
phase = (long int)que_Get(&sts, &tp->q_out, NULL, NULL);
pwr_Assert(phase == 1);
}
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;
}
static pwr_tStatus AoRangeToCoef(
io_sChannel *chanp)
{
pwr_sClass_ChanAo *cop;
char buf[120];
pwr_tStatus sts;
int i;
pwr_tFloat32 PolyCoef1;
pwr_tFloat32 PolyCoef0;
cop = chanp->cop;
if ( cop)
{
cop->CalculateNewCoef = 0;
/* Coef for ActualValue to RawValue conversion */
if ( cop->ActValRangeHigh != cop->ActValRangeLow)
{
cop->SigValPolyCoef1 = (cop->SensorSigValRangeHigh - cop->SensorSigValRangeLow)/
(cop->ActValRangeHigh - cop->ActValRangeLow);
cop->SigValPolyCoef0 = cop->SensorSigValRangeHigh - cop->ActValRangeHigh *
cop->SigValPolyCoef1;
}
else
{
sts = gdh_ObjidToName( chanp->ChanObjid, buf, sizeof(buf),
cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
errh_Error( "Invalid ActValueRange in Ao channel %s", buf);
return IO__CHANRANGE;
}
/* Coef for ActualValue to SignalValue conversion */
if ( cop->ChannelSigValRangeHigh != 0)
{
PolyCoef0 = 0;
PolyCoef1 = 2047. / cop->ChannelSigValRangeHigh;
cop->OutPolyCoef1 = cop->SigValPolyCoef1 * PolyCoef1;
cop->OutPolyCoef0 = PolyCoef0 + PolyCoef1*
cop->SigValPolyCoef0;
}
else
{
sts = gdh_ObjidToName( chanp->ChanObjid, buf, sizeof(buf),
cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
errh_Error( "Invalid SigValueRange in Ao channel %s", buf);
return IO__CHANRANGE;
}
}
return IO__SUCCESS;
}
static void lockMountServers(gdb_sNode* np)
{
pwr_tStatus sts;
pool_sQlink* msl;
pool_sQlink* vl;
gdb_sVolume* vp;
gdb_sMountServer* msp;
gdb_sObject* op;
gdb_AssumeLocked;
for (vl = pool_Qsucc(NULL, gdbroot->pool, &np->own_lh); vl != &np->own_lh;
vl = pool_Qsucc(NULL, gdbroot->pool, vl)) {
vp = pool_Qitem(vl, gdb_sVolume, l.own_ll);
if (vl->self == vl->flink) {
/* Connection lost and volume removed from own list */
errh_Error("Volume not owned any more, %s", vp->g.name.orig);
return;
}
if (!vp->l.flags.b.isConnected) {
/* !!! Todo !!! How do we make this known ? */
errh_Error("Volume not connected, %s", vp->g.name.orig);
continue;
}
for (msl = pool_Qsucc(NULL, gdbroot->pool, &vp->l.volms_lh);
msl != &vp->l.volms_lh; msl = pool_Qsucc(NULL, gdbroot->pool, msl)) {
msp = pool_Qitem(msl, gdb_sMountServer, volms_ll);
op = hash_Search(&sts, gdbroot->oid_ht, &msp->oid);
if (op == NULL) {
op = cvolc_OidToObject(
&sts, vp, msp->oid, vol_mTrans_none, cvol_eHint_none);
if (op == NULL) {
errh_Error("Can't fetch the mount server's object, %s",
cdh_ObjidToString(msp->oid, 0));
/* !!! Todo !!! How do we make this error known ? */
continue;
}
}
msp->msor = pool_ItemReference(NULL, gdbroot->pool, op);
op->l.flags.b.isMountServer = 1;
if (msp->nodms_ll.self == msp->nodms_ll.flink
&& msp->nodms_ll.self == msp->nodms_ll.blink)
pool_QinsertPred(NULL, gdbroot->pool, &msp->nodms_ll, &np->nodms_lh);
/* if (0)
errh_Info("Locking object %s", op->g.f.name.orig); */
cvolc_LockObject(&sts, op);
}
}
}
static bool status_check(pwr_sClass_Hilscher_cifX_PnController* op,
io_sAgent* ap, int sts, const char* text)
{
if (sts == CIFX_NO_ERROR)
return true;
xDriverGetErrorDescription(sts, op->ErrorStr, sizeof(op->ErrorStr));
op->Status = sts;
if (text)
errh_Error("IO init %s, '%s', %s", ap->Name, op->ErrorStr, text);
else
errh_Error("IO init %s, '%s'", ap->Name, op->ErrorStr);
return false;
}
/*----------------------------------------------------------------------------*\
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoRackInitSwap(io_tCtx ctx, io_sAgent* ap, io_sRack* rp)
{
io_sRackLocal* local;
pwr_sClass_Ssab_RemoteRack* op;
int sts;
op = (pwr_sClass_Ssab_RemoteRack*)rp->op;
local = calloc(1, sizeof(*local));
rp->Local = local;
/* Create socket, store in local struct */
local->s = socket(AF_INET, SOCK_DGRAM, 0);
if (local->s < 0) {
errh_Error(
"Error creating socket for IO remote rack %s, %d", rp->Name, local->s);
op->Status = IO__INITFAIL;
return IO__ERRINIDEVICE;
}
/* Initialize remote address structure */
local->rem_addr.sin_family = AF_INET;
local->rem_addr.sin_port = htons(op->RemotePort);
local->rem_addr.sin_addr.s_addr = inet_addr((char*)&(op->Address));
/* Connect to remote address */
sts = connect(
local->s, (struct sockaddr*)&local->rem_addr, sizeof(local->rem_addr));
if (sts != 0) {
errh_Error(
"Error binding remote socket for IO remote rack %s, %d", rp->Name, sts);
op->Status = IO__INITFAIL;
return IO__ERRINIDEVICE;
}
local->next_read_req_item = 0;
local->next_write_req_item = 0;
op->RX_packets = 0;
op->TX_packets = 0;
/* Log initialization */
errh_Info("Init of IO remote rack %s/%s:%d", rp->Name,
inet_ntoa(local->rem_addr.sin_addr), ntohs(local->rem_addr.sin_port));
op->Status = IO__NORMAL;
return IO__SUCCESS;
}
static void
stop_threads (
plc_sProcess *pp
)
{
pwr_tInt32 i;
pwr_tStatus sts;
plc_sThread *tp;
for (i = 0, tp = pp->thread; i < pp->thread_count ; i++, tp++) {
tp->exit = TRUE;
/* Tell thread it is time for phase 4, stop. */
#if defined OS_LYNX && USE_RT_TIMER
sem_post(&tp->ScanSem);
#else
que_Put(&sts, &tp->q_in, &tp->event, (void *)4);
#endif
#if 0
pwr_tStatus t_sts;
sts = thread_Join(&tp->tid, &t_sts);
if (EVEN(sts))
errh_Error("thread_Join, thread %n, %m", tp->name, sts);
#endif
}
}
int main()
{
pwr_tStatus sts;
rt_sysmon sysmon;
int tmo;
char mp[2000];
qcom_sQid qid = qcom_cNQid;
qcom_sGet get;
int swap = 0;
bool first_scan = true;
init( &qid);
try {
sysmon.open();
}
catch ( co_error& e) {
errh_Error( (char *)e.what().c_str());
errh_Fatal( "rt_sysmon aborting");
errh_SetStatus( PWR__SRVTERM);
exit(0);
}
aproc_TimeStamp( sysmon.scantime(), 5);
errh_SetStatus( PWR__SRUN);
first_scan = true;
for (;;) {
if ( first_scan) {
tmo = (int) (sysmon.scantime() * 1000 - 1);
}
get.maxSize = sizeof(mp);
get.data = mp;
qcom_Get( &sts, &qid, &get, tmo);
if (sts == QCOM__TMO || sts == QCOM__QEMPTY) {
if ( !swap)
sysmon.scan();
}
else {
ini_mEvent new_event;
qcom_sEvent *ep = (qcom_sEvent*) get.data;
new_event.m = ep->mask;
if (new_event.b.oldPlcStop && !swap) {
errh_SetStatus( PWR__SRVRESTART);
swap = 1;
sysmon.close();
} else if (new_event.b.swapDone && swap) {
swap = 0;
sysmon.open();
errh_SetStatus( PWR__SRUN);
} else if (new_event.b.terminate) {
exit(0);
}
}
first_scan = false;
}
}
static pwr_tStatus IoCardInit (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp
)
{
pwr_sClass_Ssab_PIDuP *op;
io_sLocal *local;
pwr_tStatus sts;
op = (pwr_sClass_Ssab_PIDuP *) cp->op;
local = calloc( 1, sizeof(*local));
cp->Local = local;
local->Address = op->RegAddress;
local->Qbus_fp = ((io_sRackLocal *)(rp->Local))->Qbus_fp;
errh_Info( "Init of pid card '%s'", cp->Name);
sts = gdh_ObjidToPointer(op->PidXCon, (void *) &local->objP);
if ( EVEN(sts)) {
errh_Error( "PID-card not properly connected, %s", cp->Name);
return IO__ERRDEVICE;
}
/* Calculate indexes in I/O-area */
local->dyn_ind = ((char *) &local->Dyn - (char *) local) / 2;
local->par_ind = ((char *) &local->Par - (char *) local) / 2;
local->stat_ind = ((char *) &local->Stat - (char *) local) / 2;
local->ran_ind = ((char *) &local->AoRange - (char *) local) / 2;
return 1;
}
static pwr_tStatus IoAgentWrite(io_tCtx ctx, io_sAgent* ap)
{
io_sLocalHilscher_cifX_PnController* local
= (io_sLocalHilscher_cifX_PnController*)ap->Local;
pwr_sClass_Hilscher_cifX_PnController* op
= (pwr_sClass_Hilscher_cifX_PnController*)ap->op;
int32_t sts;
if (local->output_area_size) {
sts = xChannelIOWrite(
local->chan, 0, 0, local->output_area_size, local->output_area, 10);
op->Status = sts;
if (sts != CIFX_NO_ERROR) {
if (!local->dev_init) {
op->ErrorCount++;
xDriverGetErrorDescription(sts, op->ErrorStr, sizeof(op->ErrorStr));
}
if (op->ErrorCount == op->ErrorSoftLimit && !local->softlimit_logged) {
errh_Error("IO Error soft limit reached on agent '%s'", ap->Name);
local->softlimit_logged = 1;
}
if (op->ErrorCount >= op->ErrorHardLimit) {
ctx->Node->EmergBreakTrue = 1;
return IO__ERRDEVICE;
}
}
}
return IO__SUCCESS;
}
static pwr_tStatus IoAgentInit( io_tCtx ctx,
io_sAgent *ap)
{
io_sLocalUSB_Agent *local;
int sts;
pwr_sClass_USB_Agent *op = (pwr_sClass_USB_Agent *)ap->op;
local = (io_sLocalUSB_Agent *) calloc( 1, sizeof(io_sLocalUSB_Agent));
ap->Local = local;
sts = libusb_init( &local->libusb_ctx);
if ( sts != 0) {
if ( sts == io_cLibDummy)
op->Status = IO__DUMMYBUILD;
else
op->Status = IO__INITFAIL;
errh_Error( "Init of USB agent failed '%s', error status %d", ap->Name, sts);
local->libusb_ctx = 0;
return op->Status;
}
else {
op->Status = IO__SUCCESS;
errh_Info( "Init of USBIO agent '%s'", ap->Name);
}
return IO__SUCCESS;
}
pwr_tStatus
ini_PlcStart (
pwr_tUInt32 plcversion,
char *plcfile,
pwr_tUInt32 busid
)
{
pwr_tUInt32 sts;
unsigned int flags;
char command[128];
char procname[20];
$DESCRIPTOR(commanddsc, "");
$DESCRIPTOR(procnamedsc, "");
commanddsc.dsc$a_pointer = command;
commanddsc.dsc$w_length = sprintf(command, "run %s", plcfile);
procnamedsc.dsc$a_pointer = procname;
procnamedsc.dsc$w_length = sprintf(procname, "PWR_PLC_%d", busid);
flags = 1; /* Nowait and Notify */
sts = lib$spawn(&commanddsc, NULL, NULL, &flags, &procnamedsc);
if (EVEN(sts)) errh_Error("lib$spawn %s\n%m", command, sts);
return sts;
}
/*----------------------------------------------------------------------------*\
Swap method for the Pb_profiboard agent
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoAgentSwap (
io_tCtx ctx,
io_sAgent *ap,
io_eEvent event
)
{
switch ( event) {
case io_eEvent_IoCommSwapInit:
case io_eEvent_IoCommSwap: {
pwr_sClass_Pb_Profiboard *op;
char DeviceName[64];
io_sAgentLocal *local;
if (ap->Local == NULL) {
/* Allocate area for local data structure */
ap->Local = calloc(1, sizeof(io_sAgentLocal));
if (!ap->Local) {
errh_Error( "ERROR swap init Profibus DP Master %s - %s", ap->Name, "calloc");
return IO__ERRINIDEVICE;
}
local = (io_sAgentLocal *) ap->Local;
errh_Info( "Swap init interface for Profibus DP Master %s", ap->Name);
op = (pwr_sClass_Pb_Profiboard *) ap->op;
sprintf(DeviceName, "/dev/pbboard%u", op->BusNumber - 1);
local->hDpsBoardDevice = open(DeviceName, O_RDONLY | O_NONBLOCK);
if (local->hDpsBoardDevice == -1) {
errh_Error( "ERROR swap init Profibus DP Master %s - %s", ap->Name, "open");
return IO__ERRINIDEVICE;
}
}
break;
}
case io_eEvent_EmergencyBreak:
case io_eEvent_IoCommEmergencyBreak:
IoAgentClose( ctx, ap);
break;
}
return IO__SUCCESS;
}
pwr_tBoolean
sect_InitLock (
pwr_tStatus *sts,
sect_sHead *shp,
sect_sMutex *mp
)
{
pwr_tStatus lsts = 1;
#ifdef OS_ELN
ELN$INITIALIZE_AREA_LOCK((AREA)shp->area, *mp, &lsts);
#elif defined(OS_VMS)
{
pwr_tUInt32 i;
/* Clear mutex variable and build free list. */
memset(mp, 0, sizeof(*mp));
lsts = sys$ascefc(64, &shp->namedsc, 0, 0);
if (ODD(lsts)) {
for (i=0; i<32; i++) {
while (_INSQTI(&mp->list[i].entry, &mp->freeroot) == 1);
mp->list[i].flag = 64+i;
lsts = sys$clref(mp->list[i].flag);
if (EVEN(lsts)) break;
}
}
}
#elif defined(OS_LYNX)
if (sem_init(mp, 1, 1) != 0) {
errh_Error("sect_InitLock: sem_init, errno: %d", errno);
lsts = 2;
}
#elif defined OS_POSIX
if (posix_sem_init_shared(mp, ftok(shp->name, 'P'), 1) != 0) {
errh_Error("sect_InitLock: sem_init(%s), errno: %d", shp->name, errno);
lsts = 2;
}
#endif
errh_ReturnOrBugcheck(ODD(lsts), sts, lsts, "");
}
static bool cmd_check(pwr_sClass_Hilscher_cifX_PnController* op, io_sAgent* ap,
unsigned int cmd1, unsigned int cmd2)
{
if (cmd1 == cmd2)
return true;
strcpy(op->ErrorStr, "Unexpected message received");
errh_Error("IO init %s, '%s'", ap->Name, op->ErrorStr);
return false;
}
JNIEXPORT void JNICALL Java_jpwr_rt_Errh_error
(JNIEnv *env, jobject object, jstring jmsg)
{
char *cstr;
const char *msg;
msg = (*env)->GetStringUTFChars( env, jmsg, 0);
cstr = (char *)msg;
errh_Error( cstr);
(*env)->ReleaseStringUTFChars( env, jmsg, cstr);
}
static void
clean_all (
plc_sProcess *pp
)
{
pwr_tStatus sts;
sts = gdh_UnrefObjectInfoAll();
if (EVEN(sts))
errh_Error("gdh_UnrefObjectInfoAll, %m", sts);
}
unsigned int rmq_send(remnode_item* remnode, pwr_sClass_RemTrans* remtrans,
char* buf, int buf_size)
{
int sts;
amqp_basic_properties_t prop;
amqp_bytes_t msg;
char* tmpbuf;
unsigned int tmpbuf_size;
if (rn_rmq->DisableHeader) {
msg.bytes = buf;
msg.len = buf_size;
} else {
tmpbuf_size = sizeof(rabbit_header) + buf_size;
tmpbuf = malloc(tmpbuf_size);
memcpy(tmpbuf + sizeof(rabbit_header), buf, buf_size);
((rabbit_header*)tmpbuf)->msg_size = htons(tmpbuf_size);
((rabbit_header*)tmpbuf)->msg_id[0] = htons(remtrans->Address[0]);
((rabbit_header*)tmpbuf)->msg_id[1] = htons(remtrans->Address[1]);
msg.bytes = tmpbuf;
msg.len = tmpbuf_size;
}
if ( remtrans->Address[3] == 2)
prop.delivery_mode = 2;
else
prop.delivery_mode = 1;
prop._flags = AMQP_BASIC_DELIVERY_MODE_FLAG;
// 0 mandatory 0 immediate
if (!streq(ctx->op->Exchange, ""))
sts = amqp_basic_publish(ctx->conn, ctx->channel,
amqp_cstring_bytes(ctx->op->Exchange), amqp_cstring_bytes(""), 0, 0,
&prop, msg);
else
sts = amqp_basic_publish(ctx->conn, ctx->channel,
amqp_cstring_bytes(ctx->op->Exchange),
amqp_cstring_bytes(ctx->op->SendQueue), 0, 0, &prop, msg);
if (sts) {
remtrans->ErrCount++;
errh_Error("Send failed, queue %s, RabbitMQ status %d",
rn_rmq->SendQueue, sts, 0);
if (debug)
printf("Send failed sts:%d\n", (int)sts);
}
if (!rn_rmq->DisableHeader)
free(tmpbuf);
return STATUS_OK;
}
static unsigned int Receive()
{
static int sts;
unsigned char received_char = NUL;
static unsigned char snak[2] = {NAK, NUL};
static unsigned char sdle[2] = {DLE, NUL};
//static int error_logged = 0;
fd_set read_fd;
struct timeval tv;
/**** set up timeout ****/
load_timeval(&tv, 0); // poll
// load_timeval(&tv, rn_3964R->ScanTime);
// tv.tv_sec = TIMEOUT_REC_ANSWER_SEC;
// tv.tv_usec = TIMEOUT_REC_ANSWER_USEC;
/**routine**/
FD_ZERO(&read_fd);
FD_SET(ser_fd, &read_fd);
sts=select(ser_fd+1, &read_fd, NULL, NULL, &tv);
sts=read(ser_fd, &received_char, 1);
if (sts > 0)
{
if (received_char == STX)
{
/* Write DLE to respond */
if(!write(ser_fd, sdle, 1))
return 0;
sts = ReceiveHandler(ser_fd);
}
else
{
/* We don't understand, Send NAK unless NAK is received */
if (received_char != NAK)
write(ser_fd, snak, 1);
errh_Error("3964R felaktigt meddelande i mottagning, annat starttecken än STX (0x%x)", received_char);
sts=0; //felstatus
}
if (sts < 1)
{
rn_3964R->ErrCount++;
}
}
return(1);
}
static pwr_tStatus IoRackInit( io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp)
{
io_sLocalUSB *local;
int status;
int i;
unsigned int snum;
int found;
io_sCard *cp;
pwr_sClass_MotionControl_USB *op = (pwr_sClass_MotionControl_USB *)rp->op;
local = (io_sLocalUSB *) calloc( 1, sizeof(io_sLocalUSB));
rp->Local = local;
for ( i = 0; i < (int)sizeof(local->USB_Handle); i++) {
status = USBIO_Open( &local->USB_Handle[i]);
if ( status) {
if ( i == 0)
op->Status = status;
break;
}
/* Check is this card is configured */
status = USBIO_GetSerialNr( &local->USB_Handle[i], &snum);
if ( !status) {
found = 0;
for ( cp = rp->cardlist; cp; cp = cp->next) {
if ( ((pwr_sClass_MotionControl_USBIO *)cp->op)->Super.Address == snum) {
local->snum[i] = snum;
found = 1;
break;
}
}
if ( !found) {
errh_Info( "USBIO Serial number %d not configured", snum);
op->Status = USBIO_Close( &local->USB_Handle[i]);
i--;
continue;
}
}
else
errh_Error( "USBIO Serial number error '%s'", rp->Name);
}
errh_Info( "Init of USBIO rack '%s'", rp->Name);
return IO__SUCCESS;
}
static void init(qcom_sQid* myQid)
{
pwr_tStatus sts;
sts = gdh_Init("pwr_nacp");
if (EVEN(sts)) {
errh_Fatal("gdh_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
#if defined OS_CYGWIN
qcom_sQattr qAttr;
qcom_sQid qid = qcom_cQnacp;
qAttr.type = qcom_eQtype_private;
qAttr.quota = 100;
if (!qcom_CreateQ(&sts, &qid, &qAttr, "nacp")) {
errh_Error("Failed to create QCOM que\n%m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
#else
if (!qcom_AttachQ(&sts, &qcom_cQnacp)) {
errh_Fatal("qcom_AttachQ, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
#endif
*myQid = qcom_cQnacp;
if (!qcom_Bind(&sts, myQid, &qcom_cQini)) {
errh_Fatal("qcom_Bind, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(-1);
}
/* Activate all subscriptions that were requested before we started! */
gdb_ScopeLock
{
gdbroot->db->neth_acp = *myQid;
subc_ActivateList(&gdbroot->my_node->subc_lh, pwr_cNObjid);
subc_ActivateList(&gdbroot->no_node->subc_lh, pwr_cNObjid);
}
gdb_ScopeUnlock;
}
/*----------------------------------------------------------------------------*\
Init method for the mb_master agent
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoAgentInit(io_tCtx ctx, io_sAgent* ap)
{
io_sAgentLocal* local;
/* Allocate area for local data structure */
ap->Local = calloc(1, sizeof(io_sAgentLocal));
if (!ap->Local) {
errh_Error("ERROR config Modbus Master %s - %s", ap->Name, "calloc");
return IO__ERRINIDEVICE;
}
local = ap->Local;
local->initialized = TRUE;
return IO__SUCCESS;
}
static void
dlink_area (
plc_sDlink *dp,
char *name,
int size
)
{
pwr_tStatus sts;
if ((dp->size = size) == 0) return; /* We have no objects of this type. */
sts = gdh_RefObjectInfo(name, &dp->p, &dp->sid, dp->size);
if (EVEN(sts)) {
errh_Error("Direct link object %s, %m", name, sts);
exit(sts);
}
}
static pwr_tStatus AiRangeToCoef(
io_sChannel *chanp)
{
pwr_sClass_ChanAi *cop;
char buf[120];
pwr_tStatus sts;
pwr_tFloat32 PolyCoef1;
pwr_tFloat32 PolyCoef0;
cop = chanp->cop;
if ( cop)
{
cop->CalculateNewCoef = 0;
/* Coef for RawValue to SignalValue conversion */
cop->SigValPolyCoef0 = 0;
cop->SigValPolyCoef1 = cop->ChannelSigValRangeHigh / 30000;
/* Coef for SignalValue to ActualValue conversion */
if ( chanp->ChanClass != pwr_cClass_ChanAit && cop->SensorPolyType == 1)
{
if ( cop->SensorSigValRangeHigh != cop->SensorSigValRangeLow)
{
PolyCoef1 = (cop->ActValRangeHigh - cop->ActValRangeLow)/
(cop->SensorSigValRangeHigh - cop->SensorSigValRangeLow);
PolyCoef0 = cop->ActValRangeHigh - cop->SensorSigValRangeHigh *
PolyCoef1;
cop->SensorPolyCoef1 = cop->SigValPolyCoef1 * PolyCoef1;
cop->SensorPolyCoef0 = PolyCoef0 + PolyCoef1*
cop->SigValPolyCoef0;
}
else
{
sts = gdh_ObjidToName( chanp->ChanAref.Objid, buf, sizeof(buf),
cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
errh_Error( "Invalid SigValueRange in Ai channel %s", buf);
return IO__CHANRANGE;
}
}
}
return IO__SUCCESS;
}
void rt_sysmon::open()
{
pwr_tStatus sts;
pwr_sAttrRef aref;
pwr_tObjid oid;
// Open server configuration object SysMonConfig
sts = gdh_GetClassList( pwr_cClass_SysMonConfig, &oid);
if ( ODD(sts)) {
aref = cdh_ObjidToAref( oid);
sts = gdh_DLRefObjectInfoAttrref( &aref, (void **)&conf, &conf_dlid);
if ( EVEN(sts)) throw co_error(sts);
}
if ( ODD(sts)) {
scan_time = 1.0 / conf->ScanTime;
}
else {
scan_time = 1;
errh_Info( "No sysmon configuration, using base frequency 1 Hz");
oid = pwr_cNObjid;
conf = 0;
}
aproc_RegisterObject( oid);
// Open DiskSup objects
for ( sts = gdh_GetClassListAttrRef( pwr_cClass_DiskSup, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef( pwr_cClass_DiskSup, &aref, &aref)) {
disksup_object *o = new disksup_object( &aref);
objects.push_back( o);
try {
o->open( scan_time);
if ( conf)
conf->DiskSupObjects[sysmon_cnt] = aref.Objid;
sysmon_cnt++;
}
catch ( co_error& e) {
delete o;
objects.pop_back();
errh_Error( "DiskSup configuration error: &s", (char *)e.what().c_str());
}
}
}
static pwr_tStatus IoCardInit( io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp)
{
pwr_sClass_OneWire_AiDevice *op = (pwr_sClass_OneWire_AiDevice *)cp->op;
io_sLocalAiDevice *local;
pwr_tStatus sts;
char name[40];
pwr_tFileName fname, tmp;
int name_len;
char *s;
if ( cp->chanlist[0].cop) {
local = (io_sLocalAiDevice *) calloc( 1, sizeof(io_sLocalAiDevice));
cp->Local = local;
sprintf( name, "%d-%012x", op->Family, op->Super.Address);
name_len = strlen(name);
strncpy( fname, op->DataFile, sizeof(fname));
// Replace all '%s' with 'family-serialnumber'
s = fname;
while ( (s = strstr( s, "%s"))) {
strncpy( tmp, s+2, sizeof(tmp));
strcpy( s, name);
strncat( fname, tmp, sizeof(fname));
}
local->value_fp = fopen( fname, "r");
if (!local->value_fp) {
errh_Error( "OneWire_AiDevice Unable op open %s, '%ux'", cp->Name,
op->Super.Address);
sts = IO__INITFAIL;
op->Status = sts;
return sts;
}
io_AiRangeToCoef( &cp->chanlist[0]);
errh_Info( "Init of OneWire_AiDevice '%s'", cp->Name);
}
op->Status = IO__SUCCESS;
return IO__SUCCESS;
}
