/*----------------------------------------------------------------------------*\
Write method for the Pb FDL Data transfer module
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoCardWrite (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp
)
{
io_sAgentLocal *local_agent = (io_sAgentLocal *)ap->Local;
pwr_sClass_Pb_FDL_DataTransfer *op = (pwr_sClass_Pb_FDL_DataTransfer *) cp->op;
pwr_sClass_Pb_FDL_SAP *sap = (pwr_sClass_Pb_FDL_SAP * ) rp->op;
io_sFDLCardLocal *local = (io_sFDLCardLocal *) cp->Local;
op->Status = sap->Status;
if (op->Status == PB__NORMAL) {
io_bus_card_write(ctx, cp, local->output_area, local->byte_ordering,
local->float_representation);
if (op->SendReq) {
pthread_mutex_lock(&local_agent->mutex);
if (sap->Responder) {
fdlif_reply_update_mult_req(local_agent, sap, op, local);
}
else {
fdlif_sda_sdn_sdr_req(local_agent, sap, op, local);
}
op->SendReq = 0;
pthread_mutex_unlock(&local_agent->mutex);
}
}
return IO__SUCCESS;
}
/*----------------------------------------------------------------------------*\
Write method for the Modbus RTU server module
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoCardWrite (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp
)
{
io_sServerModuleLocal *local;
io_sServerLocal *local_server;
pwr_sClass_Modbus_RTU_ServerModule *op;
pwr_sClass_Modbus_RTU_Server *server;
op = (pwr_sClass_Modbus_RTU_ServerModule *) cp->op;
local = (io_sServerModuleLocal *) cp->Local;
server = (pwr_sClass_Modbus_RTU_Server *) rp->op;
local_server = (io_sServerLocal *) rp->Local;
if ( server->DisableServer || !local)
return IO__SUCCESS;
if (server->Status == MB__NORMAL) {
thread_MutexLock( &local_server->mutex);
io_bus_card_write(ctx, cp, local->output_area, pwr_eByteOrderingEnum_BigEndian, pwr_eFloatRepEnum_FloatIntel);
thread_MutexUnlock( &local_server->mutex);
}
// printf("Method Modbus_Module-IoCardWrite\n");
return IO__SUCCESS;
}
/*----------------------------------------------------------------------------*\
Write method for the Modbus RTU module
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoCardWrite(
io_tCtx ctx, io_sAgent* ap, io_sRack* rp, io_sCard* cp)
{
io_sCardLocalMsg* local;
pwr_sClass_Modbus_RTU_Module* op;
pwr_sClass_Modbus_RTU_Slave* slave;
if (!((io_sAgentLocal*)ap->Local)->initialized)
return IO__SUCCESS;
op = (pwr_sClass_Modbus_RTU_Module*)cp->op;
local = ((io_sCardLocal*)cp->Local)->msg;
slave = (pwr_sClass_Modbus_RTU_Slave*)rp->op;
if (op->ScanInterval > 1) {
if (!local->has_read_method) {
if (local->interval_cnt != 0) {
local->interval_cnt++;
if (local->interval_cnt >= op->ScanInterval)
local->interval_cnt = 0;
return IO__SUCCESS;
}
local->interval_cnt++;
} else if (local->interval_cnt != 1)
return IO__SUCCESS;
}
if (slave->Status == MB__NORMAL) {
io_bus_card_write(ctx, cp, slave->Outputs, pwr_eByteOrderingEnum_BigEndian,
pwr_eFloatRepEnum_FloatIntel);
}
// printf("Method Modbus_RTU_Module-IoCardWrite\n");
return IO__SUCCESS;
}
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;
}
/*----------------------------------------------------------------------------*\
Write method for the Powerlink master
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoAgentWrite( io_tCtx ctx, io_sAgent *ap) {
io_sLocalEpl_MN *local = (io_sLocalEpl_MN *)ap->Local;
//pwr_sClass_Epl_MN *op = (pwr_sClass_Epl_MN *)ap->op;
io_sRack *rp;
io_sCard *cp;
if(!ap->Local)
return IO__SUCCESS;
for ( rp = ap->racklist; rp; rp = rp->next) {
for ( cp = rp->cardlist; cp; cp = cp->next) {
io_bus_card_write( ctx, cp, local->output_area, ((io_sLocalEpl_CN *)rp->Local)->byte_ordering, pwr_eFloatRepEnum_FloatIEEE);
}
}
return IO__SUCCESS;
}
/*----------------------------------------------------------------------------*\
Write method for the Pn module
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoCardWrite(
io_tCtx ctx, io_sAgent* ap, io_sRack* rp, io_sCard* cp)
{
io_sPnCardLocal* local;
pwr_sClass_PnModule* op;
pwr_sClass_PnDevice* slave;
op = (pwr_sClass_PnModule*)cp->op;
local = (io_sPnCardLocal*)cp->Local;
slave = (pwr_sClass_PnDevice*)rp->op;
op->Status = slave->Status;
if (op->Status == PB__NORMAL) {
io_bus_card_write(ctx, cp, local->output_area, slave->ByteOrdering,
slave->FloatRepresentation);
}
// printf("Method Pb_Module-IoCardWrite\n");
return IO__SUCCESS;
}
