Subversion Repositories f9daq

Compare Revisions

Ignore whitespace Rev 154 → Rev 155

/cvi/instr/MPOD/MPOD.c
5,63 → 5,155
#include <stdarg.h>
#include "MPOD.h"
 
static mpodInit=1;
HSNMP crateHsnmp[MAX_CRATES];
//************************* WIENER_SNMP.c *****************************
// WIENER SNMP basic SNMP library to Demonstrate C-Access to WIENER-Crates via SNMP
// modified for LabView import 04/23/06, Andreas Ruben
//
// The path to the Net-SNMP include files (default /usr/include) must be added to the
// include file search path!
// The following libraries must be included:
// netsnmp.lib ws2_32.lib
// The path to the Net-SNMP library must be added to the linker files.
// /usr/lib
// path for the WIENER MIB file (mibdirs) c:/usr/share/snmp/mibs
 
int _VI_FUNC MPOD_Start (void)
{
int i;
if (mpodInit) {
for (i=0;i<MAX_CRATES;i++) crateHsnmp[i]=NULL;
if(!snmpInit()) return -1; // basic init
mpodInit=0;
}
return 0;
}
//#include <windows.h>
#include "toolbox.h"
#include <ansi_c.h>
//#include "WIENER_SNMP.h"
 
int _VI_FUNC MPOD_Open (int mpodn, char *address)
{
if (crateHsnmp[mpodn]) {
printf("Crate number %i already in use!\n",mpodn);
return -2;
}
crateHsnmp[mpodn] = snmpOpen(address); // open TCP/IP socket
if(!crateHsnmp[mpodn]) return -1;
return 0;
}
#define VER_FILEVERSION 1,1,1,0
#define VER_FILEVERSION_STR "1.1.1.0\0"
 
int _VI_FUNC MPOD_GetInt (int mpodn, char *oidstr)
{
SnmpObject tmpObject;
getNode(oidstr, &tmpObject);
return snmpGetInt(crateHsnmp[mpodn], &tmpObject);
}
#ifdef _MSC_VER
#define strdup _strdup
#define vsnprintf vsprintf_s
#define strPrintf sprintf_s
#else
#define strdup StrDup
#define strPrintf snprintf
#endif
 
double _VI_FUNC MPOD_GetDouble (int mpodn, char *oidstr)
{
SnmpObject tmpObject;
getNode(oidstr, &tmpObject);
return snmpGetDouble(crateHsnmp[mpodn], &tmpObject);
}
#ifndef UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P) (void)(P)
#endif
 
int _VI_FUNC MPOD_Close (int mpodn)
{
snmpClose(crateHsnmp[mpodn]);
crateHsnmp[mpodn]=NULL;
return 0;
}
#define false 0;
#define true 1;
 
int _VI_FUNC MPOD_End (void)
{
if (!mpodInit) {
snmpCleanup(); // finish
mpodInit=1;
}
return 0;
}
 
static const char WienerMibFileName[] = "WIENER-CRATE-MIB";
static const char DefaultReadCommunity[] = "public"; ///< default community name for read operations
static const char DefaultWriteCommunity[] = "guru"; ///< default community name for write operation
 
static char *m_readCommunity = (char *)DefaultReadCommunity;
static char *m_writeCommunity = (char *)DefaultWriteCommunity;
 
/**
* @brief The SnmpObject class is used internally to resolve OIDs and for the SNMP calls.
*/
//class SnmpObject {
//public:
typedef struct {
oid id[MAX_OID_LEN]; ///< The resolved SNMP OID
size_t len; ///< The resolved OIDs length in byte
char desc[100]; ///< The OIDs textual representation, e.g. "sysDescr.0"
} SnmpObject;
//typedef struct snmp_object SnmpObject;
 
static SnmpObject moduleIndex[MaxSlotsPerCrate];
static SnmpObject moduleDescription[MaxSlotsPerCrate];
static SnmpObject moduleSupply[MaxModuleAuxSupplies][MaxSlotsPerCrate];
static SnmpObject moduleHardwareLimitVoltage[MaxSlotsPerCrate];
static SnmpObject moduleHardwareLimitCurrent[MaxSlotsPerCrate];
static SnmpObject moduleRampSpeedVoltage[MaxSlotsPerCrate];
static SnmpObject moduleRampSpeedCurrent[MaxSlotsPerCrate];
static SnmpObject moduleStatus[MaxSlotsPerCrate];
static SnmpObject moduleEventStatus[MaxSlotsPerCrate];
static SnmpObject moduleDoClear[MaxSlotsPerCrate];
static SnmpObject moduleAuxiliaryMeasurementTemperature[MaxModuleAuxTemperatures][MaxSlotsPerCrate];
 
static SnmpObject sysDescr;
static SnmpObject sysMainSwitch;
static SnmpObject sysStatus;
static SnmpObject sysVmeSysReset;
static SnmpObject outputNumber;
static SnmpObject groupsNumber;
static SnmpObject highVoltageGroupsSwitch;
static SnmpObject lowVoltageGroupsSwitch;
static SnmpObject ipStaticAddress;
 
static SnmpObject outputName[MaxChannelsPerCrate];
static SnmpObject outputIndex[MaxChannelsPerCrate];
static SnmpObject outputGroup[MaxChannelsPerCrate];
static SnmpObject outputStatus[MaxChannelsPerCrate];
static SnmpObject outputMeasurementSenseVoltage[MaxChannelsPerCrate];
static SnmpObject outputMeasurementTerminalVoltage[MaxChannelsPerCrate];
static SnmpObject outputMeasurementCurrent[MaxChannelsPerCrate];
static SnmpObject outputMeasurementTemperature[MaxChannelsPerCrate];
static SnmpObject outputSwitch[MaxChannelsPerCrate];
static SnmpObject outputVoltage[MaxChannelsPerCrate];
static SnmpObject outputCurrent[MaxChannelsPerCrate];
static SnmpObject outputVoltageRiseRate[MaxChannelsPerCrate];
static SnmpObject outputVoltageFallRate[MaxChannelsPerCrate];
static SnmpObject outputCurrentRiseRate[MaxChannelsPerCrate];
static SnmpObject outputCurrentFallRate[MaxChannelsPerCrate];
static SnmpObject outputSupervisionBehavior[MaxChannelsPerCrate];
static SnmpObject outputSupervisionMinSenseVoltage[MaxChannelsPerCrate];
static SnmpObject outputSupervisionMaxSenseVoltage[MaxChannelsPerCrate];
static SnmpObject outputSupervisionMaxTerminalVoltage[MaxChannelsPerCrate];
static SnmpObject outputSupervisionMaxCurrent[MaxChannelsPerCrate];
static SnmpObject outputSupervisionMaxTemperature[MaxChannelsPerCrate];
static SnmpObject outputConfigMaxSenseVoltage[MaxChannelsPerCrate];
static SnmpObject outputConfigMaxTerminalVoltage[MaxChannelsPerCrate];
static SnmpObject outputConfigMaxCurrent[MaxChannelsPerCrate];
static SnmpObject outputSupervisionMaxPower[MaxChannelsPerCrate];
static SnmpObject outputTripTimeMaxCurrent[MaxChannelsPerCrate];
 
static SnmpObject sensorNumber;
static SnmpObject sensorTemperature[MaxSensors];
static SnmpObject sensorWarningThreshold[MaxSensors];
static SnmpObject sensorFailureThreshold[MaxSensors];
 
//static SnmpObject psFirmwareVersion;
static SnmpObject psSerialNumber;
static SnmpObject psOperatingTime;
static SnmpObject psDirectAccess;
static SnmpObject fanNumberOfFans;
static SnmpObject fanOperatingTime;
//static SnmpObject fanFirmwareVersion;
static SnmpObject fanSerialNumber;
static SnmpObject fanAirTemperature;
static SnmpObject fanSwitchOffDelay;
static SnmpObject fanNominalSpeed;
static SnmpObject fanSpeed[MaxFans];
 
static SnmpObject psAuxVoltage[MaxPsAuxSupplies];
static SnmpObject psAuxCurrent[MaxPsAuxSupplies];
 
static SnmpObject snmpCommunityName[MaxCommunities];
 
//static double snmpSetDouble(HSNMP session, const SnmpObject &object, double value);
static double snmpSetDouble(HSNMP session, const SnmpObject *object, double value);
static double snmpGetDouble(HSNMP session, const SnmpObject *object);
static int snmpSetInt(HSNMP session, const SnmpObject *object, int value);
static int snmpGetInt(HSNMP session, const SnmpObject *object);
static char *snmpGetString(HSNMP session, const SnmpObject *object);
 
char snmpStringBuffer[1024];
char snmpLastErrorBuffer[1024];
 
SnmpDoubleBuffer snmpDoubleBuffer;
SnmpIntegerBuffer snmpIntegerBuffer;
 
//************************************************************************
static int getNode(const char * const node, SnmpObject *object);
static int getIndexNode(const char * const nodeBase, int index, SnmpObject *object);
 
 
static mpodInit=1;
HSNMP crateHsnmp[MAX_CRATES];
 
#ifdef MPOD_MAIN
int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpszCmdLine, int nCmdShow) {
87,7 → 179,8
iret=getMainSwitch(crate1);
printf("Main Switch = %i\n", iret);
 
iret=MPOD_GetInt(0,"moduleNumber.0");
// iret=MPOD_GetInt(0,"moduleNumber.0");
iret=MPOD_GetIntCh(0,"moduleNumber",0);
printf("Module Number = %i\n", iret);
 
ret=MPOD_GetDouble(0,"outputVoltage.1");
140,3 → 233,2285
}
 
#endif /* MPOD_MAIN */
 
int _VI_FUNC MPOD_Start (void)
{
int i;
if (mpodInit) {
for (i=0;i<MAX_CRATES;i++) crateHsnmp[i]=NULL;
if(!snmpInit()) return -1; // basic init
mpodInit=0;
}
return 0;
}
 
int _VI_FUNC MPOD_Open (int mpodn, char *address)
{
if (crateHsnmp[mpodn]) {
printf("Crate number %i already in use!\n",mpodn);
return -2;
}
crateHsnmp[mpodn] = snmpOpen(address); // open TCP/IP socket
if(!crateHsnmp[mpodn]) return -1;
return 0;
}
 
int _VI_FUNC MPOD_GetInt (int mpodn, char *oidstr)
{
SnmpObject tmpObject;
getNode(oidstr, &tmpObject);
return snmpGetInt(crateHsnmp[mpodn], &tmpObject);
}
 
int _VI_FUNC MPOD_SetInt (int mpodn, char *oidstr, int iset)
{
SnmpObject tmpObject;
getNode(oidstr, &tmpObject);
return snmpSetInt(crateHsnmp[mpodn], &tmpObject, iset);
}
 
double _VI_FUNC MPOD_GetDouble (int mpodn, char *oidstr)
{
SnmpObject tmpObject;
getNode(oidstr, &tmpObject);
return snmpGetDouble(crateHsnmp[mpodn], &tmpObject);
}
 
double _VI_FUNC MPOD_SetDouble (int mpodn, char *oidstr, double dset)
{
SnmpObject tmpObject;
getNode(oidstr, &tmpObject);
return snmpSetDouble(crateHsnmp[mpodn], &tmpObject, dset);
}
 
int _VI_FUNC MPOD_GetIntCh (int mpodn, char *oidstrbase, int ich)
{
SnmpObject tmpObject;
getIndexNode(oidstrbase, ich, &tmpObject);
return snmpGetInt(crateHsnmp[mpodn], &tmpObject);
}
 
int _VI_FUNC MPOD_SetIntCh (int mpodn, char *oidstrbase, int ich, int iset)
{
SnmpObject tmpObject;
getIndexNode(oidstrbase, ich, &tmpObject);
return snmpSetInt(crateHsnmp[mpodn], &tmpObject, iset);
}
 
double _VI_FUNC MPOD_GetDoubleCh (int mpodn, char *oidstrbase, int ich)
{
SnmpObject tmpObject;
getIndexNode(oidstrbase, ich, &tmpObject);
return snmpGetDouble(crateHsnmp[mpodn], &tmpObject);
}
 
double _VI_FUNC MPOD_SetDoubleCh (int mpodn, char *oidstrbase, int ich,
double dset)
{
SnmpObject tmpObject;
getIndexNode(oidstrbase, ich, &tmpObject);
return snmpSetDouble(crateHsnmp[mpodn], &tmpObject, dset);
}
 
int _VI_FUNC MPOD_Close (int mpodn)
{
snmpClose(crateHsnmp[mpodn]);
crateHsnmp[mpodn]=NULL;
return 0;
}
 
int _VI_FUNC MPOD_End (void)
{
if (!mpodInit) {
snmpCleanup(); // finish
mpodInit=1;
}
return 0;
}
 
//************************* WIENER_SNMP.c *****************************
#ifdef _MSC_VER
 
BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
UNREFERENCED_PARAMETER(hModule);
UNREFERENCED_PARAMETER(ul_reason_for_call);
UNREFERENCED_PARAMETER(lpReserved);
 
return TRUE;
}
 
#endif
 
/**
* @brief Simple logging function with printf-like usage.
* @internal
* @param priority
* @param format
*/
static void sysLog(int priority, const char *format, ...)
{
UNREFERENCED_PARAMETER(priority);
 
va_list vaPrintf;
va_start(vaPrintf, format);
vprintf(format, vaPrintf);
putchar('\n');
 
// store errors in snmpLastErrorBuffer, which can be read by snmpGetLastError()
if (priority == LOG_ERR)
vsnprintf(snmpLastErrorBuffer, sizeof(snmpLastErrorBuffer), format, vaPrintf);
 
va_end(vaPrintf);
}
 
// Helper functions
 
/**
* @brief Resolves the OID from the textual SNMP description
* and stores the OID in *object.
* @internal
* @param node e.g. "sysMainSwitch"
* @param object the resolved OID
* @return true on success, false otherwise
*/
static int getNode(const char * const node, SnmpObject *object)
{
object->len = MAX_OID_LEN;
if (!get_node(node, object->id, &object->len)) {
snmp_log(LOG_ERR, "OID %s not found!\n", node);
return false;
}
 
#ifdef _MSC_VER
strcpy_s(object->desc, sizeof(object->desc), node);
#else
strncpy(object->desc, node, sizeof(object->desc));
#endif
 
return true;
}
 
/**
* @brief Resolves the OID from the textual SNMP description
* with appended index and stores the OID in *object.
* @internal
* @param nodeBase e.g. "outputSwitch"
* @param index e.g. 100
* @param object the resolved OID
* @return true on success, false otherwise
*/
static int getIndexNode(const char * const nodeBase, int index, SnmpObject *object)
{
char node[100];
 
strPrintf(node, sizeof(node), "%s.%i", nodeBase, index);
 
return getNode(node, object);
}
 
/**
* @brief Activates logging on stderr console.
* @since 1.1
* @note This is the default setting.
*/
void snmpSetStdErrLog(void)
{
snmp_enable_stderrlog();
}
 
/**
* @brief Activates logging to the file filename.
* @since 1.1
* @param fileName The full path to the file where all log
* information should go to.
* @note If the specified file already exists,
* new log information is appended.
*/
void snmpSetFileLog(const char * const fileName)
{
snmp_enable_filelog(fileName, 1);
}
 
/**
* @brief Returns the library four digit version number as unsigned int value.
*
* This allows to check for a specific version number.
* @since 1.1
* @return The version number as unsigned long value, e.g. 0x01010000
*/
unsigned int snmpGetVersion(void)
{
const uint32_t version[] = { VER_FILEVERSION };
 
return (version[0] << 24) + (version[1] << 16) + (version[2] << 8) + version[3];
}
 
/**
* @brief Returns the library four digit version number as null-terminated string.
*
* The digits are separated by dots.
* @since 1.1
* @return The version number, e.g. "1.1.0.3"
*/
char *snmpGetVersionString(void)
{
return VER_FILEVERSION_STR;
}
 
/**
* @brief Setup the default conditions for logging and SNMP passwords.
* @internal
*/
static void setDefaultSettings(void)
{
snmpSetStdErrLog();
 
m_readCommunity = (char *)DefaultReadCommunity;
m_writeCommunity = (char *)DefaultWriteCommunity;
 
memset(snmpLastErrorBuffer, 0, sizeof(snmpLastErrorBuffer));
}
 
/**
* @brief SNMP Initialization.
*
* Resolves all needed OIDs from the MIB file and prepares the SNMP communication.
* The actual connection to a MPOD crate is done with snmpOpen().
* @return true on success, false otherwise (e.g. an OID could not be resolved)
*/
int snmpInit(void)
{
setDefaultSettings();
 
snmp_log(LOG_DEBUG, "*** Initialise SNMP ***\n");
 
init_snmp("WIENER_SNMP_DLL");
init_mib(); // init MIB processing
if (!read_module(WienerMibFileName)) { // read specific mibs
snmp_log(LOG_ERR, "Unable to load SNMP MIB file \"%s\"\n", WienerMibFileName);
return false;
}
snmp_log(LOG_DEBUG, "*** Translate OIDs ***\n");
 
// Translate System OIDS
getNode("sysDescr.0", &sysDescr); // FIXME: doesn't work atm in Linux
 
if (
(!getNode("sysMainSwitch.0", &sysMainSwitch)) ||
(!getNode("sysStatus.0", &sysStatus)) ||
(!getNode("sysVmeSysReset.0", &sysVmeSysReset)) ||
(!getNode("outputNumber.0", &outputNumber)) ||
(!getNode("groupsNumber.0", &groupsNumber)) ||
(!getNode("groupsSwitch.64", &highVoltageGroupsSwitch)) ||
(!getNode("groupsSwitch.128", &lowVoltageGroupsSwitch)) ||
(!getNode("ipStaticAddress.0", &ipStaticAddress)) ||
// (!getNode("psFirmwareVersion.0", &psFirmwareVersion)) ||
(!getNode("psSerialNumber.0", &psSerialNumber)) ||
(!getNode("psOperatingTime.0", &psOperatingTime)) ||
(!getNode("psDirectAccess.0", &psDirectAccess)) ||
(!getNode("sensorNumber.0", &sensorNumber)) ||
// (!getNode("fanFirmwareVersion.0", &fanFirmwareVersion)) ||
(!getNode("fanSerialNumber.0", &fanSerialNumber)) ||
(!getNode("fanOperatingTime.0", &fanOperatingTime)) ||
(!getNode("fanAirTemperature.0", &fanAirTemperature))||
(!getNode("fanSwitchOffDelay.0", &fanSwitchOffDelay)) ||
(!getNode("fanNominalSpeed.0", &fanNominalSpeed)) ||
(!getNode("fanNumberOfFans.0", &fanNumberOfFans))
) {
return false;
}
 
// Translate module and channel information OIDs
for (int slot = 0; slot < MaxSlotsPerCrate; ++slot) {
 
if (
(!getIndexNode("moduleIndex", slot + 1, &moduleIndex[slot])) ||
(!getIndexNode("moduleDescription", slot + 1, &moduleDescription[slot])) ||
(!getIndexNode("moduleAuxiliaryMeasurementVoltage0", slot + 1, &moduleSupply[0][slot])) ||
(!getIndexNode("moduleAuxiliaryMeasurementVoltage1", slot + 1, &moduleSupply[1][slot])) ||
(!getIndexNode("moduleAuxiliaryMeasurementTemperature0", slot + 1, &moduleAuxiliaryMeasurementTemperature[0][slot])) ||
(!getIndexNode("moduleAuxiliaryMeasurementTemperature1", slot + 1, &moduleAuxiliaryMeasurementTemperature[1][slot])) ||
(!getIndexNode("moduleAuxiliaryMeasurementTemperature2", slot + 1, &moduleAuxiliaryMeasurementTemperature[2][slot])) ||
(!getIndexNode("moduleAuxiliaryMeasurementTemperature3", slot + 1, &moduleAuxiliaryMeasurementTemperature[3][slot])) ||
(!getIndexNode("moduleHardwareLimitVoltage", slot + 1, &moduleHardwareLimitVoltage[slot])) ||
(!getIndexNode("moduleHardwareLimitCurrent", slot + 1, &moduleHardwareLimitCurrent[slot])) ||
(!getIndexNode("moduleRampSpeedVoltage", slot + 1, &moduleRampSpeedVoltage[slot])) ||
(!getIndexNode("moduleRampSpeedCurrent", slot + 1, &moduleRampSpeedCurrent[slot])) ||
(!getIndexNode("moduleStatus", slot + 1, &moduleStatus[slot])) ||
(!getIndexNode("moduleEventStatus", slot + 1, &moduleEventStatus[slot])) ||
(!getIndexNode("moduleDoClear", slot + 1, &moduleDoClear[slot]))
) {
return false;
}
 
int base = MaxChannelsPerSlot * slot; // array index
 
for (int channel = base; channel < base + MaxChannelsPerSlot; ++channel) {
if (
(!getIndexNode("outputName", channel + 1, &outputName[channel])) ||
(!getIndexNode("outputIndex", channel + 1, &outputIndex[channel])) ||
(!getIndexNode("outputGroup", channel + 1, &outputGroup[channel])) ||
(!getIndexNode("outputStatus", channel + 1, &outputStatus[channel])) ||
(!getIndexNode("outputMeasurementSenseVoltage", channel + 1, &outputMeasurementSenseVoltage[channel])) ||
(!getIndexNode("outputMeasurementTerminalVoltage", channel + 1, &outputMeasurementTerminalVoltage[channel])) ||
(!getIndexNode("outputMeasurementCurrent", channel + 1, &outputMeasurementCurrent[channel])) ||
(!getIndexNode("outputMeasurementTemperature", channel + 1, &outputMeasurementTemperature[channel])) ||
(!getIndexNode("outputSwitch", channel + 1, &outputSwitch[channel])) ||
(!getIndexNode("outputVoltage", channel + 1, &outputVoltage[channel])) ||
(!getIndexNode("outputCurrent", channel + 1, &outputCurrent[channel])) ||
(!getIndexNode("outputVoltageRiseRate", channel + 1, &outputVoltageRiseRate[channel])) ||
(!getIndexNode("outputVoltageFallRate", channel + 1, &outputVoltageFallRate[channel])) ||
(!getIndexNode("outputCurrentRiseRate", channel + 1, &outputCurrentRiseRate[channel])) ||
(!getIndexNode("outputCurrentFallRate", channel + 1, &outputCurrentFallRate[channel])) ||
(!getIndexNode("outputSupervisionBehavior", channel + 1, &outputSupervisionBehavior[channel])) ||
(!getIndexNode("outputSupervisionMinSenseVoltage", channel + 1, &outputSupervisionMinSenseVoltage[channel])) ||
(!getIndexNode("outputSupervisionMaxSenseVoltage", channel + 1, &outputSupervisionMaxSenseVoltage[channel])) ||
(!getIndexNode("outputSupervisionMaxTerminalVoltage", channel + 1, &outputSupervisionMaxTerminalVoltage[channel])) ||
(!getIndexNode("outputSupervisionMaxCurrent", channel + 1, &outputSupervisionMaxCurrent[channel])) ||
// (!getIndexNode("outputSupervisionMaxTemperature", channel + 1, &outputSupervisionMaxTemperature[channel])) ||
(!getIndexNode("outputConfigMaxSenseVoltage", channel + 1, &outputConfigMaxSenseVoltage[channel])) ||
(!getIndexNode("outputConfigMaxTerminalVoltage", channel + 1, &outputConfigMaxTerminalVoltage[channel])) ||
(!getIndexNode("outputSupervisionMaxPower", channel + 1, &outputSupervisionMaxPower[channel])) ||
(!getIndexNode("outputConfigMaxCurrent", channel + 1, &outputConfigMaxCurrent[channel])) ||
(!getIndexNode("outputTripTimeMaxCurrent", channel + 1, &outputTripTimeMaxCurrent[channel]))
) {
return false;
}
}
}
 
for (int sensor = 0; sensor < MaxSensors; ++sensor)
if (
(!getIndexNode("sensorTemperature", sensor + 1, &sensorTemperature[sensor])) ||
(!getIndexNode("sensorWarningThreshold", sensor + 1, &sensorWarningThreshold[sensor])) ||
(!getIndexNode("sensorFailureThreshold", sensor + 1, &sensorFailureThreshold[sensor]))
) {
return false;
}
 
for (int name = 0; name < MaxCommunities; ++name)
if (!getIndexNode("snmpCommunityName", name + 1, &snmpCommunityName[name]))
return false;
 
for (int fan = 0; fan < MaxFans; ++fan)
if (!getIndexNode("fanSpeed", fan + 1, &fanSpeed[fan]))
return false;
 
for (int aux = 0; aux < MaxPsAuxSupplies; ++aux) {
if (
(!getIndexNode("psAuxiliaryMeasurementVoltage", aux + 1, &psAuxVoltage[aux])) ||
(!getIndexNode("psAuxiliaryMeasurementCurrent", aux + 1, &psAuxCurrent[aux]))
) {
return false;
}
}
 
snmp_log(LOG_DEBUG, "*** Initialise SNMP done ***\n");
SOCK_STARTUP; // only in main thread
 
return true;
}
 
/**
* @brief Additional cleanup. Should be called after snmpClose.
*/
void snmpCleanup(void)
{
SOCK_CLEANUP;
}
 
/**
* @brief Set a new read community name for SNMP access.
*
* The read community name has to match the configured read community name in the MPOD.
* The default read community name is "public".
* @since 1.1
* @note This function must be called before snmpOpen().
* @param readCommunityName the new read community name
*/
void snmpSetReadCommunityName(const char * const readCommunityName)
{
m_readCommunity = strdup(readCommunityName);
}
 
/**
* @brief Set a new write community name for SNMP access.
*
* The write community name has to match the configured write community name in the MPOD.
* The default write community name is "guru".
* @since 1.1
* @note This function must be called before any write access function.
* @param writeCommunityName the new write community name
*/
void snmpSetWriteCommunityName(const char * const writeCommunityName)
{
m_writeCommunity = strdup(writeCommunityName);
}
 
/**
* @brief Opens a SNMP session to the specified ipAddress.
*
* This function also sets the number of retries and the timeout value.
* @param ipAddress a zero-terminated ASCII string representation
* of an IPv4 address, e.g. "192.168.17.101"
* @return a handle to the opened SNMP session, which is a required
* parameter for any further call.
*/
HSNMP snmpOpen(const char * const ipAddress)
{
HSNMP session;
struct snmp_session snmpSession;
snmp_sess_init(&snmpSession); // structure defaults
snmpSession.version = SNMP_VERSION_2c;
snmpSession.peername = strdup(ipAddress);
snmpSession.community = (u_char *)strdup(m_readCommunity);
snmpSession.community_len = strlen(m_readCommunity);
 
snmpSession.timeout = 300000; // timeout (us)
snmpSession.retries = 2; // retries
 
if (!(session = snmp_sess_open(&snmpSession))) {
int liberr, syserr;
char *errstr;
snmp_error(&snmpSession, &liberr, &syserr, &errstr);
snmp_log(LOG_ERR, "Open SNMP session for host \"%s\": %s\n", ipAddress, errstr);
free(errstr);
return 0;
}
 
snmp_log(LOG_INFO, "SNMP session for host \"%s\" opened\n", ipAddress);
return session;
}
 
/**
* @brief Closes the previously opened session specified by session.
* @param session The handle returned by snmpOpen()
*/
void snmpClose(HSNMP session)
{
if (!session)
return;
 
if (!snmp_sess_close(session))
snmp_log(LOG_ERR, "Close SNMP session: ERROR\n");
else
snmp_log(LOG_INFO, "SNMP session closed\n");
}
 
/**
* @brief Returns a pointer to a descriptive string for the last failed SNMP operation.
* @return a pointer to a zero-terminated error string for the last failed
* SNMP operation. Note: this pointer is valid until the next string operation.
*/
char *snmpGetLastError(void)
{
return snmpLastErrorBuffer;
}
 
// System Information Functions
 
/**
* @brief Returns a pointer to the MPOD controller description string.
*
* The pointer is valid until the next call of any string function.
* @param session The handle returned by snmpOpen()
* @return the MPOD controller description string, containing the
* controller serial number and firmware releases, e.g.:
* "WIENER MPOD (4388090, MPOD 2.1.2098.1, MPODslave 1.09, MPOD-BL 1.50 )"
*/
char *getSysDescr(HSNMP session)
{
return snmpGetString(session, &sysDescr);
}
 
/**
* @brief Returns the crate power on/off status.
*
* The result is the logical "and" between the hardware main switch
* and the setMainSwitch function.
* @param session The handle returned by snmpOpen()
* @return The current on/off status of the crate:
* 0: crate is powered off
* 1: crate is powered on
*/
int getMainSwitch(HSNMP session)
{
return snmpGetInt(session, &sysMainSwitch);
}
 
/**
* @brief Sets the crate main switch to 1 = on or 0 = off.
*
* If the hardware main switch is set to "0" position, this function always returns 0.
* @param session The handle returned by snmpOpen()
* @param value 0 = set off, 1 = set on
* @return The new on/off status of the crate.
*/
int setMainSwitch(HSNMP session, int value)
{
return snmpSetInt(session, &sysMainSwitch, value);
}
 
/**
* @brief Returns a bit field with the status of the complete crate.
* @param session The handle returned by snmpOpen()
* @return The complete crate status.
*/
int getMainStatus(HSNMP session)
{
return snmpGetInt(session, &sysStatus);
}
 
/**
* @brief Returns the VME system reset status.
* @param session The handle returned by snmpOpen()
* @return
*/
int getVmeReset(HSNMP session)
{
return snmpGetInt(session, &sysVmeSysReset);
}
 
/**
* @brief Initiate a VME system reset.
* @param session The handle returned by snmpOpen()
* @return
*/
int setVmeReset(HSNMP session)
{
return snmpSetInt(session, &sysVmeSysReset, 1);
}
 
/**
* @brief Returns the static IP address as 32 bit integer.
* @param session The handle returned by snmpOpen()
* @return The static IP address.
*/
int getIpStaticAddress(HSNMP session)
{
return snmpGetInt(session, &ipStaticAddress);
}
 
/**
* @brief Sets a new static IP address.
* @param session The handle returned by snmpOpen()
* @param value The IP address as 32 bit integer
* @return
*/
int setIpStaticAddress(HSNMP session, int value)
{
return snmpSetInt(session, &ipStaticAddress, value);
}
 
/**
* @brief Returns a pointer to a string containing the MPOD controllers serial number.
*
* The pointer is valid until the next call of any string function.
* @param session The handle returned by snmpOpen()
* @return The crates serial number, e.g. "4388090".
*/
char *getPsSerialNumber(HSNMP session)
{
return snmpGetString(session, &psSerialNumber);
}
 
// System Count Functions
 
/**
* @brief Returns the total number of output channels in the crate.
* @param session The handle returned by snmpOpen()
* @return The total number of output channels
*/
int getOutputNumber(HSNMP session)
{
return snmpGetInt(session, &outputNumber);
}
 
/**
* @brief getOutputGroups
* @param session The handle returned by snmpOpen()
* @return
*/
int getOutputGroups(HSNMP session)
{
return snmpGetInt(session, &groupsNumber);
}
 
// Output Channel Information
 
/**
* @brief getOutputGroup
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
int getOutputGroup(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetInt(session, &outputGroup[channel]);
}
 
/**
* @brief Returns the channel outputStatus register.
* @note This function is deprecated. Use getOutputStatus() instead.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The channels outputStatus register
*/
int getChannelStatus(HSNMP session, int channel)
{
return getOutputStatus(session, channel);
}
 
/**
* @brief Returns the channel outputStatus register.
* @since 1.1
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The channels outputStatus register
*/
int getOutputStatus(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetInt(session, &outputStatus[channel]);
}
 
/**
* @brief Returns the measured output sense voltage for channel in Volt.
* @note This is only valid for WIENER LV modules.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputSenseMeasurement(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputMeasurementSenseVoltage[channel]);
}
 
/**
* @brief Returns the measured output terminal voltage for channel in Volt.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The measured output terminal voltage in Volt.
*/
double getOutputTerminalMeasurement(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputMeasurementTerminalVoltage[channel]);
}
 
/**
* @brief Returns the measured output current for channel in Ampere.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The measured output measurement current in Ampere.
*/
double getCurrentMeasurement(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputMeasurementCurrent[channel]);
}
 
/**
* @brief Returns the measured temperature for channel in Degree Celsius.
* @note Only WIENER Low Voltage modules have a channel-wise temperature measurement.
* For iseg HV modules, use getModuleAuxTemperature().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The measured output temperature in Degree Celsius.
*/
int getTemperatureMeasurement(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetInt(session, &outputMeasurementTemperature[channel]);
}
 
/**
* @brief Change the state of the channel.
* @note This function is deprecated. Use setOutputSwitch() instead.
* @param session The handle returned by snmpOpen()
* @param channel The channel in the range of 0...999
* @param value One of the following: off (0), on (1),
* resetEmergencyOff (2), setEmergencyOff (3), clearEvents (10).
* @return
*/
int setChannelSwitch(HSNMP session, int channel, int value)
{
return setOutputSwitch(session, channel, value);
}
 
/**
* @brief Change the state of the channel.
* @since 1.1
* @param session The handle returned by snmpOpen()
* @param channel The channel in the range of 0...999
* @param value One of the following: off (0), on (1),
* resetEmergencyOff (2), setEmergencyOff (3), clearEvents (10).
* @return
*/
int setOutputSwitch(HSNMP session, int channel, int value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetInt(session, &outputSwitch[channel], value);
}
 
/**
* @brief Returns the state of the channel.
* @note This function is deprecated. Use getOutputSwitch() instead.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return One of the following: off (0), on (1),
* resetEmergencyOff (2), setEmergencyOff (3), clearEvents (10).
*/
int getChannelSwitch(HSNMP session, int channel)
{
return getOutputSwitch(session, channel);
}
 
/**
* @brief Returns the state of the channel.
* @since 1.1
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return One of the following: off (0), on (1),
* resetEmergencyOff (2), setEmergencyOff (3), clearEvents (10).
*/
int getOutputSwitch(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetInt(session, &outputSwitch[channel]);
}
 
/**
* @brief setHighVoltageGroupsSwitch
* @param session The handle returned by snmpOpen()
* @param value
* @return
*/
int setHighVoltageGroupsSwitch(HSNMP session, int value)
{
return snmpSetInt(session, &highVoltageGroupsSwitch, value);
}
 
/**
* @brief getHighVoltageGroupsSwitch
* @param session The handle returned by snmpOpen()
* @return
*/
int getHighVoltageGroupsSwitch(HSNMP session)
{
return snmpGetInt(session, &highVoltageGroupsSwitch);
}
 
/**
* @brief setLowVoltageGroupsSwitch
* @param session The handle returned by snmpOpen()
* @param value
* @return
*/
int setLowVoltageGroupsSwitch(HSNMP session, int value)
{
return snmpSetInt(session, &lowVoltageGroupsSwitch, value);
}
 
/**
* @brief getLowVoltageGroupsSwitch
* @param session The handle returned by snmpOpen()
* @return
*/
int getLowVoltageGroupsSwitch(HSNMP session)
{
return snmpGetInt(session, &lowVoltageGroupsSwitch);
}
 
/**
* @brief Returns the demanded output voltage for channel.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The demanded output voltage in Volt.
*/
double getOutputVoltage(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputVoltage[channel]);
}
 
/**
* @brief Sets the demanded output voltage for channel.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @param value the demanded output voltage in Volt.
* @return The demanded output voltage in Volt.
*/
double setOutputVoltage(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputVoltage[channel], value);
}
 
/**
* @brief Returns the demanded maximum output current for channel.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The demanded output current in Ampere.
*/
double getOutputCurrent(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputCurrent[channel]);
}
 
/**
* @brief Sets the demanded maximum output current for channel.
* @param session The handle returned by snmpOpen()
* @param channel The channel in the range of 0...999
* @param value The demanded ouput current in Ampere
* @return The demanded maximum output current in Ampere.
*/
double setOutputCurrent(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputCurrent[channel], value);
}
 
/**
* @brief Returns the channel voltage rise rate in Volt/second.
*
* @note This function is for WIENER LV only.
* For iseg HV modules, use getModuleRampSpeedVoltage().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputRiseRate(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputVoltageRiseRate[channel]);
}
 
/**
* @brief Sets the channel voltage rise rate in Volt/second.
*
* @note This function is for WIENER LV only.
* For iseg HV modules, use setModuleRampSpeedVoltage().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @param value
* @return
*/
double setOutputRiseRate(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputVoltageRiseRate[channel], value);
}
 
/**
* @brief Returns the channel voltage fall rate in Volt/second.
*
* @note This function is for WIENER LV only.
* For iseg HV modules, use getModuleRampSpeedVoltage().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputFallRate(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputVoltageFallRate[channel]);
}
 
/**
* @brief Sets the channel voltage fall rate in Volt/second.
*
* @note This function is for WIENER LV only.
* For iseg HV modules, use setModuleRampSpeedVoltage().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @param value
* @return
*/
double setOutputFallRate(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputVoltageFallRate[channel], value);
}
 
/**
* @brief Returns the channel current rise rate in Ampere/second.
*
* @note This function is for WIENER LV only.
* For iseg HV modules, use getModuleRampSpeedCurrent().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputCurrentRiseRate(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputCurrentRiseRate[channel]);
}
 
/**
* @brief Sets the channel current rise rate in Ampere/second.
*
* @note This function is for WIENER LV only.
* For iseg HV modules, use setModuleRampSpeedCurrent().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @param value
* @return
*/
double setOutputCurrentRiseRate(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputCurrentRiseRate[channel], value);
}
 
/**
* @brief Returns the channel current fall rate in Ampere/second.
*
* @note This function is for WIENER LV only.
* For iseg HV modules, use getModuleRampSpeedCurrent().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputCurrentFallRate(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputCurrentFallRate[channel]);
}
 
/**
* @brief Sets the channel current fall rate in Ampere/second.
*
* @note This function is for WIENER LV only.
* For iseg HV modules, use setModuleRampSpeedCurrent().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @param value
* @return
*/
double setOutputCurrentFallRate(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputCurrentFallRate[channel], value);
}
 
/**
* @brief Returns a bit field packed into an integer
* which define the behavior of the output channel or power supply after failures.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
int getOutputSupervisionBehavior(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetInt(session, &outputSupervisionBehavior[channel]);
}
 
/**
* @brief Set the behavior of the output channel or power supply after failures.
*
* For each supervision value, a two-bit field exists.
* The enumeration of this value (..L+..H*2) is:
* WIENER LV devices
* 0 ignore the failure
* 1 switch off this channel
* 2 switch off all channels with the same group number
* 3 switch off the complete crate.
* iseg HV devices
* 0 ignore the failure
* 1 switch off this channel by ramp down the voltage
* 2 switch off this channel by a emergencyOff
* 3 switch off the whole board of the HV module by emergencyOff.
* The position of the bit fields in the integer value are:
* Bit 0, 1: outputFailureMinSenseVoltage
* Bit 2, 3: outputFailureMaxSenseVoltage
* Bit 4, 5: outputFailureMaxTerminalVoltage
* Bit 6, 7: outputFailureMaxCurrent
* Bit 8, 9: outputFailureMaxTemperature
* Bit 10, 11: outputFailureMaxPower
* Bit 12, 13: outputFailureInhibit
* Bit 14, 15: outputFailureTimeout
* @param session The handle returned by snmpOpen()
* @param channel The channel (0...999) for which the behaviour should be set
* @param value The 16 bit integer with bits set according the preceding table.
* @return
*/
int setOutputSupervisionBehavior(HSNMP session, int channel, int value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetInt(session, &outputSupervisionBehavior[channel], value );
}
 
/**
* @brief getOutputSupervisionMinSenseVoltage
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputSupervisionMinSenseVoltage(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputSupervisionMinSenseVoltage[channel]);
}
 
/**
* @brief setOutputSupervisionMinSenseVoltage
* @param session The handle returned by snmpOpen()
* @param channel
* @param value
* @return
*/
double setOutputSupervisionMinSenseVoltage(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputSupervisionMinSenseVoltage[channel], value);
}
 
/**
* @brief getOutputSupervisionMaxSenseVoltage
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputSupervisionMaxSenseVoltage(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputSupervisionMaxSenseVoltage[channel]);
}
 
/**
* @brief setOutputSupervisionMaxSenseVoltage
* @param session The handle returned by snmpOpen()
* @param channel
* @param value
* @return
*/
double setOutputSupervisionMaxSenseVoltage(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputSupervisionMaxSenseVoltage[channel], value);
}
 
/**
* @brief If the measured voltage at the power supply output terminals is above this value,
* the power supply performs the function defined by setOutputSupervisionBehavior().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The maximum terminal voltage in Volt
*/
double getOutputSupervisionMaxTerminalVoltage(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputSupervisionMaxTerminalVoltage[channel]);
}
 
/**
* @brief If the measured voltage at the power supply output terminals is above this value,
* the power supply performs the function defined by setOutputSupervisionBehavior().
* @param session The handle returned by snmpOpen()
* @param channel the channel (0...999) to set the max. terminal voltage
* @param value The maximum terminal voltage in Volt
* @return
*/
double setOutputSupervisionMaxTerminalVoltage(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputSupervisionMaxTerminalVoltage[channel], value);
}
 
/**
* @brief If the measured current is above this value, the power supply
* performs the function defined by setOutputSupervisionBehavior().
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The maximum output current in Ampere
*/
double getOutputSupervisionMaxCurrent(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputSupervisionMaxCurrent[channel]);
}
 
/**
* @brief If the measured current is above this value, the power supply
* performs the function defined by setOutputSupervisionBehavior().
* @param session The handle returned by snmpOpen()
* @param channel The channel (0...999) to set the max. current
* @param value The maximum current in Ampere
* @return
*/
double setOutputSupervisionMaxCurrent(HSNMP session, int channel, double value)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetDouble(session, &outputSupervisionMaxCurrent[channel], value );
}
 
/**
* @brief getOutputSupervisionMaxTemperature
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return The maximum temperature in degree Celsius
*/
int getOutputSupervisionMaxTemperature(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetInt(session, &outputSupervisionMaxTemperature[channel]);
}
 
/**
* @brief getOutputConfigMaxSenseVoltage
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputConfigMaxSenseVoltage(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputConfigMaxSenseVoltage[channel]);
}
 
/**
* @brief getOutputConfigMaxTerminalVoltage
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputConfigMaxTerminalVoltage(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputConfigMaxTerminalVoltage[channel]);
}
 
/**
* @brief getOutputConfigMaxCurrent
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputConfigMaxCurrent(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputConfigMaxCurrent[channel]);
}
 
/**
* @brief getOutputSupervisionMaxPower
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return
*/
double getOutputSupervisionMaxPower(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetDouble(session, &outputSupervisionMaxPower[channel]);
}
 
/**
* @brief Returns the time span for the delayed trip function.
* @param session The handle returned by snmpOpen()
* @param channel The requested channel in the range of 0...999
* @return the trip delay time (0...4000 ms)
*/
int getOutputTripTimeMaxCurrent(HSNMP session, int channel)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpGetInt(session, &outputTripTimeMaxCurrent[channel]);
}
 
/**
* @brief Defines a span for the delayed trip function.
* @param session The handle returned by snmpOpen()
* @param channel The channel (0...999) for which to set the delayed trip
* @param delay The trip delay time (0...4000 ms)
* @return
*/
int setOutputTripTimeMaxCurrent(HSNMP session, int channel, int delay)
{
if (channel < 0 || channel >= MaxChannelsPerCrate)
return 0;
 
return snmpSetInt(session, &outputTripTimeMaxCurrent[channel], delay);
}
 
// Sensor Information functions
 
int getSensorNumber(HSNMP session)
{
return snmpGetInt(session, &sensorNumber);
}
 
int getSensorTemp(HSNMP session, int sensor)
{
if (sensor < 0 || sensor > MaxSensors)
return 0;
 
return snmpGetInt(session, &sensorTemperature[sensor]);
}
 
int getSensorWarningTemperature(HSNMP session, int sensor)
{
if (sensor < 0 || sensor > MaxSensors)
return 0;
 
return snmpGetInt(session, &sensorWarningThreshold[sensor]);
}
 
int setSensorWarningTemperature(HSNMP session, int sensor, int value)
{
if (sensor < 0 || sensor > MaxSensors)
return 0;
 
return snmpSetInt(session, &sensorWarningThreshold[sensor], value);
}
 
int getSensorFailureTemperature(HSNMP session, int sensor)
{
if (sensor < 0 || sensor > MaxSensors)
return 0;
 
return snmpGetInt(session, &sensorFailureThreshold[sensor]);
}
 
int setSensorFailureTemperature(HSNMP session, int sensor, int value)
{
if (sensor < 0 || sensor > MaxSensors)
return 0;
 
return snmpSetInt(session, &sensorFailureThreshold[sensor], value);
}
 
// Power Supply specific Functions.
 
/**
* @brief Returns the crates operating time in seconds.
* @param session The handle returned by snmpOpen()
* @return
*/
int getPsOperatingTime(HSNMP session)
{
return snmpGetInt(session, &psOperatingTime);
}
 
double getPsAuxVoltage(HSNMP session, int auxIndex)
{
if ( (auxIndex < 0) || (auxIndex >= MaxPsAuxSupplies) )
return 0.0;
 
return snmpGetDouble(session, &psAuxVoltage[auxIndex]);
}
 
double getPsAuxCurrent(HSNMP session, int auxIndex)
{
if ( (auxIndex < 0) || (auxIndex >= MaxPsAuxSupplies) )
return 0.0;
 
return snmpGetDouble(session, &psAuxCurrent[auxIndex]);
}
 
// Fan Tray Functions
 
int getFanOperatingTime(HSNMP session)
{
return snmpGetInt(session, &fanOperatingTime);
}
 
int getFanAirTemperature(HSNMP session)
{
return snmpGetInt(session, &fanAirTemperature);
}
 
int getFanSwitchOffDelay(HSNMP session)
{
return snmpGetInt(session, &fanSwitchOffDelay);
}
 
int setFanSwitchOffDelay(HSNMP session, int value)
{
return snmpSetInt(session, &fanSwitchOffDelay, value);
}
 
/**
* @brief Returns the MPODs fan rotation speed in revolutions per minute.
* @param session The handle returned by snmpOpen()
* @return
*/
int getFanNominalSpeed(HSNMP session)
{
return snmpGetInt(session, &fanNominalSpeed);
}
 
/**
* @brief Sets the MPODs fan rotation speed in revolutions per minute.
* @param session The handle returned by snmpOpen()
* @param value 1200..3600. 0 turns off the crates fans.
* @return
*/
int setFanNominalSpeed(HSNMP session, int value)
{
return snmpSetInt(session, &fanNominalSpeed, value );
}
 
int getFanNumberOfFans(HSNMP session)
{
return snmpGetInt(session, &fanNumberOfFans);
}
 
int getFanSpeed(HSNMP session, int fan)
{
if (fan < 0 || fan > MaxFans)
return 0;
 
return snmpGetInt(session, &fanSpeed[fan]);
}
 
/**
* @brief Returns a pointer to the module description string.
*
* The pointer is valid until the next call of any string function.
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @return A string with the following contents, separated by comma and space:
* - The module vendor ("iseg" or "WIENER")
* - The module type name
* - The channel number
* - The module serial number (optional)
* - The module firmware release (optional)
*
* Example: "iseg, E24D1, 24, 715070, 5.14"
*/
char *getModuleDescription(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0;
 
return snmpGetString(session, &moduleDescription[slot]);
}
 
/**
* @brief Returns the measured value of the modules +24 Volt line.
* @note This function is for iseg HV modules only.
* @param session The handle returned by snmpOpen()
* @param slot the modules slot position in the crate (0...9)
* @return the measured +24 Volt line voltage in Volt.
*/
double getModuleSupply24(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
return snmpGetDouble(session, &moduleSupply[0][slot]);
}
 
/**
* @brief Returns the measured value of the modules +5 Volt line.
* @note This function is for iseg HV modules only.
* @param session The handle returned by snmpOpen()
* @param slot the modules slot position in the crate (0...9)
* @return the measured +5 Volt line voltage in Volt.
*/
double getModuleSupply5(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
return snmpGetDouble(session, &moduleSupply[1][slot]);
}
 
/**
* @brief Returns the measured value of one of the modules temperature sensors.
*
* @note This function is for iseg HV modules only.
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @param index The temperature sensor index (0...3)
* @note Most modules only have one temperature sensor at index 0.
* @return
*/
double getModuleAuxTemperature(HSNMP session, int slot, int index)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
if (index < 0 || index >= MaxModuleAuxTemperatures)
return 0.0;
 
return snmpGetDouble(session, &moduleAuxiliaryMeasurementTemperature[index][slot]);
}
 
/**
* @brief Returns the modules hardware voltage limit in percent.
*
* @note This function is for iseg HV modules only.
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @return The modules hardware voltage limit in percent (2...102)
*/
double getModuleHardwareLimitVoltage(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
return snmpGetDouble(session, &moduleHardwareLimitVoltage[slot]);
}
 
/**
* @brief Returns the modules hardware current limit in percent.
*
* @note This function is for iseg HV modules only.
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @return The modules hardware current limit in percent (2...102)
*/
double getModuleHardwareLimitCurrent(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
return snmpGetDouble(session, &moduleHardwareLimitCurrent[slot]);
}
 
/**
* @brief Returns the modules voltage ramp speed in percent.
*
* @note This function is for iseg HV modules only.
* iseg modules have one common ramp speed for all channels.
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @return The modules voltage ramp speed in percent
*/
double getModuleRampSpeedVoltage(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
return snmpGetDouble(session, &moduleRampSpeedVoltage[slot]);
}
 
/**
* @brief Sets the modules voltage ramp speed in percent.
*
* @note This function is for iseg HV modules only.
*
* iseg modules have one common ramp speed for all channels.
* @param session The handle returned by snmpOpen()
* @param slot the modules slot position in the crate (0...9)
* @param value The new voltage ramp speed in percent
* @note For most modules, the range is 0.001...20 percent.
* @return The new voltage ramp speed in percent
*/
double setModuleRampSpeedVoltage(HSNMP session, int slot, double value)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
return snmpSetDouble(session, &moduleRampSpeedVoltage[slot], value);
}
 
/**
* @brief Returns the modules current ramp speed in percent.
*
* @note This function is for iseg HV modules only.
*
* iseg modules have one common ramp speed for all channels.
* This item is only valid for modules with constant current regulation.
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @return The modules current ramp speed in percent
*/
double getModuleRampSpeedCurrent(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
return snmpGetDouble(session, &moduleRampSpeedCurrent[slot]);
}
 
/**
* @brief Sets the modules current ramp speed in percent.
*
* @note This function is for iseg HV modules only.
*
* iseg modules have one common ramp speed for all channels.
* This item is only valid for modules with constant current regulation.
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @param value The new current ramp speed in percent
* @return The new current ramp speed in percent
*/
double setModuleRampSpeedCurrent(HSNMP session, int slot, double value)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0.0;
 
return snmpSetDouble(session, &moduleRampSpeedCurrent[slot], value);
}
 
/**
* @brief Returns the value of the module status register.
*
* @note This function is for iseg HV modules only.
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @return The module status register
*/
int getModuleStatus(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0;
 
return snmpGetInt(session, &moduleStatus[slot]);
}
 
/**
* @brief Returns the value of the module event status register.
*
* @note This function is for iseg HV modules only.
* @param session The handle returned by snmpOpen()
* @param slot the modules slot position in the crate (0...9)
* @return The module event status register
*/
int getModuleEventStatus(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0;
 
return snmpGetInt(session, &moduleEventStatus[slot]);
}
 
/**
* @brief Clears all modules events in a specific slot.
*
* To clear all events in all iseg HV modules, use setHighVoltageGroupsSwitch()
* with the parameter clearEvents(10).
* @param session The handle returned by snmpOpen()
* @param slot The modules slot position in the crate (0...9)
* @return
*/
int setModuleDoClear(HSNMP session, int slot)
{
if (slot < 0 || slot >= MaxSlotsPerCrate)
return 0;
 
return snmpSetInt(session, &moduleDoClear[slot], 1);
}
 
// The rest of the functions are utility functions that actually do the SNMP calls
 
static void logErrors(HSNMP session, struct snmp_pdu *response,
const SnmpObject *object, int status, const char *functionName)
{
// FAILURE: print what went wrong!
if (status == STAT_SUCCESS)
snmp_log(LOG_ERR, "%s(%s): Error in packet. Reason: %s\n",
functionName, object->desc, snmp_errstring(response->errstat));
else
snmp_sess_perror("snmpget", snmp_sess_session(session));
}
 
static int getIntegerVariable(struct variable_list *vars)
{
if (vars->type == ASN_BIT_STR || vars->type == ASN_OCTET_STR) {
int value = 0;
for (size_t i = 0; i < vars->val_len && i < sizeof(int); ++i)
value |= (vars->val.bitstring[i] << (i * 8));
return value;
} if (vars->type == ASN_OPAQUE_FLOAT)
return (int)*vars->val.floatVal;
else if (vars->type == ASN_OPAQUE_DOUBLE)
return (int)*vars->val.doubleVal;
else if (vars->type == ASN_INTEGER)
return *vars->val.integer;
else if (vars->type == ASN_OCTET_STR)
return *vars->val.integer;
else if (vars->type == ASN_IPADDRESS)
return *vars->val.integer;
 
return 0;
}
 
static double getDoubleVariable(struct variable_list *vars)
{
if (vars->type == ASN_OPAQUE_FLOAT)
return *vars->val.floatVal;
else if (vars->type == ASN_OPAQUE_DOUBLE)
return *vars->val.doubleVal;
else if (vars->type == ASN_INTEGER)
return (double)*vars->val.integer;
 
return 0.0;
}
 
static struct snmp_pdu *prepareSetRequestPdu(void)
{
struct snmp_pdu *pdu = snmp_pdu_create(SNMP_MSG_SET);
pdu->community = (u_char *)strdup(m_writeCommunity);
pdu->community_len = strlen(m_writeCommunity);
 
return pdu;
}
 
static struct snmp_pdu *prepareGetRequestPdu()
{
struct snmp_pdu *pdu = snmp_pdu_create(SNMP_MSG_GET);
 
return pdu;
}
 
static int snmpGetInt(HSNMP session, const SnmpObject *object)
{
int value = 0;
 
struct snmp_pdu *pdu = prepareGetRequestPdu();
 
snmp_add_null_var(pdu, object->id, object->len); // generate request data
 
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
value = getIntegerVariable(response->variables);
} else {
logErrors(session, response, object, status, "snmpGetInt");
return 0;
}
 
snmp_free_pdu(response);
return value;
}
 
static int snmpSetInt(HSNMP session, const SnmpObject *object, int value)
{
struct snmp_pdu *pdu = prepareSetRequestPdu();
 
if (snmp_oid_compare(object->id, object->len, ipStaticAddress.id, ipStaticAddress.len) == 0)
snmp_pdu_add_variable(pdu, object->id, object->len, ASN_IPADDRESS, (u_char *)&value, sizeof(value));
else
snmp_pdu_add_variable(pdu, object->id, object->len, ASN_INTEGER, (u_char *)&value, sizeof(value));
 
int result = value;
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
result = getIntegerVariable(response->variables);
} else {
logErrors(session, response, object, status, "snmpSetInt");
return 0;
}
 
snmp_free_pdu(response);
return result;
}
 
static double snmpGetDouble(HSNMP session, const SnmpObject *object)
{
double value = 0.0;
 
struct snmp_pdu *pdu = prepareGetRequestPdu();
 
snmp_add_null_var(pdu, object->id, object->len); // generate request data
 
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
value = getDoubleVariable(response->variables);
} else {
logErrors(session, response, object, status, "snmpGetDouble");
return 0;
}
 
snmp_free_pdu(response);
return value;
}
 
static double snmpSetDouble(HSNMP session, const SnmpObject *object, double value)
{
struct snmp_pdu *pdu = prepareSetRequestPdu();
 
float v = (float)value;
snmp_pdu_add_variable(pdu, object->id, object->len, ASN_OPAQUE_FLOAT, (u_char *)&v, sizeof(v));
 
double result = v;
 
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
result = getDoubleVariable(response->variables);
} else {
logErrors(session, response, object, status, "snmpSetDouble");
return 0;
}
 
snmp_free_pdu(response);
return result;
}
 
static char *snmpGetString(HSNMP session, const SnmpObject *object)
{
struct snmp_pdu *pdu = prepareGetRequestPdu();
 
snmp_add_null_var(pdu, object->id, object->len); // generate request data
 
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
memset(snmpStringBuffer, 0, sizeof(snmpStringBuffer));
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
struct variable_list *vars = response->variables;
if (vars->type == ASN_OCTET_STR) {
size_t len = sizeof(snmpStringBuffer) - 1;
if (len > vars->val_len)
len = vars->val_len;
 
memcpy(snmpStringBuffer, vars->val.string, len);
snmpStringBuffer[len] = 0;
}
} else {
logErrors(session, response, object, status, "snmpGetString");
return 0;
}
 
snmp_free_pdu(response);
return snmpStringBuffer;
}
 
static SnmpIntegerBuffer *snmpGetMultipleInteger(HSNMP session, const SnmpObject *objects, int size)
{
struct snmp_pdu *pdu = prepareGetRequestPdu();
 
if (size > MaxChannelsPerSlot)
size = MaxChannelsPerSlot;
 
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
 
for (int i = 0; i < size; ++i)
snmp_add_null_var(pdu, objects[i].id, objects[i].len); // generate request data
 
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
struct variable_list *vars;
for (vars = response->variables; vars; vars = vars->next_variable)
snmpIntegerBuffer.value[snmpIntegerBuffer.size++] = getIntegerVariable(vars);
} else {
logErrors(session, response, &objects[0], status, "snmpGetMultipleInteger");
return &snmpIntegerBuffer;
}
 
snmp_free_pdu(response);
return &snmpIntegerBuffer;
}
 
static SnmpIntegerBuffer *snmpSetMultipleInteger(HSNMP session, const SnmpObject *objects, SnmpIntegerBuffer *values)
{
struct snmp_pdu *pdu = prepareSetRequestPdu();
 
int size = values->size;
if (size > MaxChannelsPerSlot)
size = MaxChannelsPerSlot;
 
for (int i = 0; i < size; ++i) {
int v = values->value[i];
snmp_pdu_add_variable(pdu, objects[i].id, objects[i].len, ASN_INTEGER, (u_char *)&v, sizeof(v));
}
 
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
 
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
struct variable_list *vars;
for (vars = response->variables; vars; vars = vars->next_variable)
snmpIntegerBuffer.value[snmpIntegerBuffer.size++] = getIntegerVariable(vars);
} else {
logErrors(session, response, &objects[0], status, "snmpSetMultipleInteger");
return &snmpIntegerBuffer;
}
 
snmp_free_pdu(response);
return &snmpIntegerBuffer;
}
 
static SnmpDoubleBuffer *snmpGetMultipleDouble(HSNMP session, const SnmpObject *objects, int size)
{
struct snmp_pdu *pdu = prepareGetRequestPdu();
 
if (size > MaxChannelsPerSlot)
size = MaxChannelsPerSlot;
 
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
 
for (int i = 0; i < size; ++i)
snmp_add_null_var(pdu, objects[i].id, objects[i].len); // generate request data
 
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
struct variable_list *vars;
for (vars = response->variables; vars; vars = vars->next_variable)
snmpDoubleBuffer.value[snmpDoubleBuffer.size++] = getDoubleVariable(vars);
} else {
logErrors(session, response, &objects[0], status, "snmpGetMultipleDouble");
return &snmpDoubleBuffer;
}
 
snmp_free_pdu(response);
 
return &snmpDoubleBuffer;
}
 
static SnmpDoubleBuffer *snmpSetMultipleDouble(HSNMP session, const SnmpObject *objects, SnmpDoubleBuffer *values)
{
struct snmp_pdu *pdu = prepareSetRequestPdu();
 
int size = values->size;
if (size > MaxChannelsPerSlot)
size = MaxChannelsPerSlot;
 
for (int i = 0; i < size; ++i) {
float v = (float)values->value[i];
snmp_pdu_add_variable(pdu, objects[i].id, objects[i].len, ASN_OPAQUE_FLOAT, (u_char *)&v, sizeof(v));
}
 
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
 
struct snmp_pdu *response;
int status = snmp_sess_synch_response(session, pdu, &response);
 
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
struct variable_list *vars;
for (vars = response->variables; vars; vars = vars->next_variable)
snmpDoubleBuffer.value[snmpDoubleBuffer.size++] = getDoubleVariable(vars);
} else {
logErrors(session, response, &objects[0], status, "snmpSetMultipleDouble");
return &snmpDoubleBuffer;
}
 
snmp_free_pdu(response);
return &snmpDoubleBuffer;
}
 
/**
* @brief Returns an array with the outputStatus for a consecutive range of channels.
*
* @note This function is deprecated. Use getMultipleOutputStatuses() instead.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return A pointer to SnmpIntegerBuffer with the requested information.
* @note This pointer is only valid until the next call of getMultiple...
* or setMultiple... function.
*/
SnmpIntegerBuffer *getMultipleChannelStatuses(HSNMP session, int start, int size)
{
return getMultipleOutputStatuses(session, start, size);
}
 
/**
* @brief Returns an array with the outputStatus for a consecutive range of channels.
* @since 1.1
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return A pointer to SnmpIntegerBuffer with the requested information.
* @note This pointer is only valid until the next call of getMultiple...
* or setMultiple... function.
*/
SnmpIntegerBuffer *getMultipleOutputStatuses(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
return &snmpIntegerBuffer;
}
 
return snmpGetMultipleInteger(session, &outputStatus[start], size);
}
 
/**
* @brief Returns an array with the outputSwitches for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return A pointer to SnmpIntegerBuffer with the requested information.
* @note This pointer is only valid until the next call of getMultiple...
* or setMultiple... function.
*/
SnmpIntegerBuffer *getMultipleOutputSwitches(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
return &snmpIntegerBuffer;
}
 
return snmpGetMultipleInteger(session, &outputSwitch[start], size);
}
 
/**
* @brief Sets the outputSwitch for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param values A pointer to SnmpIntegerBuffer with the list of outputSwitches.
* @return
*/
SnmpIntegerBuffer *setMultipleOutputSwitches(HSNMP session, int start, SnmpIntegerBuffer *values)
{
if (start < 0 || values->size < 0 || start + values->size > MaxChannelsPerCrate) {
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
return &snmpIntegerBuffer;
}
 
return snmpSetMultipleInteger(session, &outputSwitch[start], values);
}
 
/**
* @brief Returns the actual outputVoltage for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return A pointer to SnmpDoubleBuffer with the requested information.
* @note This pointer is only valid until the next call of getMultiple...
* or setMultiple... function.
*/
SnmpDoubleBuffer *getMultipleOutputVoltages(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
return &snmpDoubleBuffer;
}
 
return snmpGetMultipleDouble(session, &outputVoltage[start], size);
}
 
/**
* @brief Sets the demanded outputVoltage for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param values A pointer to SnmpDoubleBuffer with the list of new outputVoltages
* @return
*/
SnmpDoubleBuffer *setMultipleOutputVoltages(HSNMP session, int start, SnmpDoubleBuffer *values)
{
if (start < 0 || values->size < 0 || start + values->size > MaxChannelsPerCrate) {
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
return &snmpDoubleBuffer;
}
 
return snmpSetMultipleDouble(session, &outputVoltage[start], values);
}
 
/**
* @brief Returns the measured terminal voltages for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return A pointer to SnmpDoubleBuffer with the requested information.
* @note This pointer is only valid until the next call of getMultiple...
* or setMultiple... function.
*/
SnmpDoubleBuffer *getMultipleMeasurementTerminalVoltages(HSNMP session, int start, int size)
{
return getMultipleOutputMeasurementTerminalVoltages(session, start, size);
}
 
/**
* @brief Returns an array with the measured terminal voltages for a consecutive range of channels.
* @since 1.1
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return A pointer to SnmpDoubleBuffer with the requested information.
* @note This pointer is only valid until the next call of getMultiple...
* or setMultiple... function.
*/
SnmpDoubleBuffer *getMultipleOutputMeasurementTerminalVoltages(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
return &snmpDoubleBuffer;
}
 
return snmpGetMultipleDouble(session, &outputMeasurementTerminalVoltage[start], size);
}
 
/**
* @brief getMultipleOutputConfigMaxTerminalVoltages
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return
*/
SnmpDoubleBuffer *getMultipleOutputConfigMaxTerminalVoltages(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
return &snmpDoubleBuffer;
}
 
return snmpGetMultipleDouble(session, &outputConfigMaxTerminalVoltage[start], size);
}
 
/**
* @brief Returns an array the demanded output currents for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return
*/
SnmpDoubleBuffer *getMultipleOutputCurrents(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
return &snmpDoubleBuffer;
}
 
return snmpGetMultipleDouble(session, &outputCurrent[start], size);
}
 
/**
* @brief Sets the demanded output current for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param values A pointer to SnmpDoubleBuffer with a list of new output currents
* @return
*/
SnmpDoubleBuffer *setMultipleOutputCurrents(HSNMP session, int start, SnmpDoubleBuffer *values)
{
if (start < 0 || values->size < 0 || start + values->size > MaxChannelsPerCrate) {
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
return &snmpDoubleBuffer;
}
 
return snmpSetMultipleDouble(session, &outputCurrent[start], values);
}
 
/**
* @brief Returns an array with the measured currents for a consecutive range of channels.
*
* @note This function is deprecated. Use getMultipleOutputMeasurementCurrents() instead.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return A pointer to SnmpDoubleBuffer with the requested information.
* @note This pointer is only valid until the next call of getMultiple...
* or setMultiple... function.
*/
SnmpDoubleBuffer *getMultipleMeasurementCurrents(HSNMP session, int start, int size)
{
return getMultipleOutputMeasurementCurrents(session, start, size);
}
 
/**
* @brief Returns an array with the measured currents for a consecutive range of channels.
* @since 1.1
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return A pointer to SnmpDoubleBuffer with the requested information.
* @note This pointer is only valid until the next call of getMultiple...
* or setMultiple... function.
*/
SnmpDoubleBuffer *getMultipleOutputMeasurementCurrents(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
return &snmpDoubleBuffer;
}
 
return snmpGetMultipleDouble(session, &outputMeasurementCurrent[start], size);
}
 
/**
* @brief Returns an array with the outputConfigMaxCurrent for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return
*/
SnmpDoubleBuffer *getMultipleOutputConfigMaxCurrents(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
return &snmpDoubleBuffer;
}
 
return snmpGetMultipleDouble(session, &outputConfigMaxCurrent[start], size);
}
 
/**
* @brief Returns an array with the outputTripTimeMaxCurrent for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return
*/
SnmpIntegerBuffer *getMultipleOutputTripTimeMaxCurrents(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
return &snmpIntegerBuffer;
}
 
return snmpGetMultipleInteger(session, &outputTripTimeMaxCurrent[start], size);
}
 
/**
* @brief Sets the outputTripTimeMaxCurrent for a consecutive ranges of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param values
* @return
*/
SnmpIntegerBuffer *setMultipleOutputTripTimeMaxCurrents(HSNMP session, int start, SnmpIntegerBuffer *values)
{
if (start < 0 || values->size < 0 || start + values->size > MaxChannelsPerCrate) {
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
return &snmpIntegerBuffer;
}
 
return snmpSetMultipleInteger(session, &outputTripTimeMaxCurrent[start], values);
}
 
/**
* @brief Returns an array with the outputSupervisionBehavior for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param size The number of requested channels.
* @return
*/
SnmpIntegerBuffer *getMultipleOutputSupervisionBehaviors(HSNMP session, int start, int size)
{
if (start < 0 || size < 0 || start + size > MaxChannelsPerCrate) {
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
return &snmpIntegerBuffer;
}
 
return snmpGetMultipleInteger(session, &outputSupervisionBehavior[start], size);
}
 
/**
* @brief Sets the outputSupervisionBehavior for a consecutive range of channels.
* @param session The handle returned by snmpOpen()
* @param start The first channel (in the range of 0 to MaxArraySize).
* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
* @param values The new outputSupervisionBehavior for the all channels starting with start.
* @return
*/
SnmpIntegerBuffer *setMultipleOutputSupervisionBehaviors(HSNMP session, int start, SnmpIntegerBuffer *values)
{
if (start < 0 || values->size < 0 || start + values->size > MaxChannelsPerCrate) {
memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
return &snmpIntegerBuffer;
}
 
return snmpSetMultipleInteger(session, &outputSupervisionBehavior[start], values);
}
//************************************************************************
/cvi/instr/MPOD/MPOD.fp
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property
Index: instr/MPOD/MPOD.h
===================================================================
--- instr/MPOD/MPOD.h (nonexistent)
+++ instr/MPOD/MPOD.h (revision 155)
@@ -0,0 +1,240 @@
+#ifndef __MPOD_H__
+#define __MPOD_H__
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+#include <cvidef.h>
+#include <ivi.h>
+//#include "WIENER_SNMP.h"
+//************************* WIENER_SNMP.h *****************************
+#ifdef _MSC_VER
+#define EXPORT extern "C" _declspec(dllexport)
+#else
+#define EXPORT extern "C"
+#endif
+
+#define WIN32_LEAN_AND_MEAN
+
+//SAMO #include <net-snmp/net-snmp-config.h>
+#include "net-snmp-config.h" // SAMO
+//SAMO #define NET_SNMP_SNMPV3_H // we don't need SNMPV3 (one include file is missing)
+#include <net-snmp/net-snmp-includes.h>
+
+typedef void *HSNMP; // SNMP handle (like FILE)
+
+// DLL functions
+EXPORT void snmpSetStdErrLog(void);
+EXPORT void snmpSetFileLog(const char * const fileName);
+EXPORT unsigned int snmpGetVersion(void);
+EXPORT char *snmpGetVersionString(void);
+
+EXPORT int snmpInit(void);
+EXPORT void snmpCleanup(void);
+EXPORT void snmpSetReadCommunityName(const char * const readCommunityName);
+EXPORT void snmpSetWriteCommunityName(const char * const writeCommunityName);
+
+EXPORT HSNMP snmpOpen(const char * const ipAddress);
+EXPORT void snmpClose(HSNMP session);
+EXPORT char *snmpGetLastError(void);
+
+// System Functions
+EXPORT char *getSysDescr(HSNMP session);
+EXPORT int getMainSwitch(HSNMP session);
+EXPORT int setMainSwitch(HSNMP session, int value);
+EXPORT int getMainStatus(HSNMP session);
+EXPORT int getVmeReset(HSNMP session);
+EXPORT int setVmeReset(HSNMP session);
+EXPORT int getIpStaticAddress(HSNMP session);
+EXPORT int setIpStaticAddress(HSNMP session, int value);
+EXPORT char *getPsSerialNumber(HSNMP session);
+
+// Output Counts
+EXPORT int getOutputNumber(HSNMP session);
+EXPORT int getOutputGroups(HSNMP session);
+
+//Output Channel Information
+//std::string getOutputName(HSNMP session, int channel);
+EXPORT int getOutputGroup(HSNMP session, int channel);
+EXPORT int getOutputStatus(HSNMP session, int channel);
+EXPORT int getChannelStatus(HSNMP m_sessmp, int channel);
+EXPORT double getOutputSenseMeasurement(HSNMP session, int channel);
+EXPORT double getOutputTerminalMeasurement(HSNMP session, int channel);
+EXPORT double getCurrentMeasurement(HSNMP session, int channel);
+EXPORT int getTemperatureMeasurement(HSNMP session, int channel);
+EXPORT int setChannelSwitch(HSNMP session, int channel, int value);
+EXPORT int setOutputSwitch(HSNMP session, int channel, int value);
+EXPORT int getChannelSwitch(HSNMP session, int channel);
+EXPORT int getOutputSwitch(HSNMP session, int channel);
+EXPORT int setHighVoltageGroupsSwitch(HSNMP session, int value);
+EXPORT int getHighVoltageGroupsSwitch(HSNMP session);
+EXPORT int setLowVoltageGroupsSwitch(HSNMP session, int value);
+EXPORT int getLowVoltageGroupsSwitch(HSNMP session);
+EXPORT double getOutputVoltage(HSNMP session, int channel);
+EXPORT double setOutputVoltage(HSNMP session, int channel, double value);
+EXPORT double getOutputCurrent(HSNMP session, int channel);
+EXPORT double setOutputCurrent(HSNMP session, int channel, double value);
+EXPORT double getOutputRiseRate(HSNMP session, int channel);
+EXPORT double setOutputRiseRate(HSNMP session, int channel, double value);
+EXPORT double getOutputFallRate(HSNMP session, int channel);
+EXPORT double setOutputFallRate(HSNMP session, int channel, double value);
+EXPORT double getOutputCurrentRiseRate(HSNMP session, int channel);
+EXPORT double setOutputCurrentRiseRate(HSNMP session, int channel, double value);
+EXPORT double getOutputCurrentFallRate(HSNMP session, int channel);
+EXPORT double setOutputCurrentFallRate(HSNMP session, int channel, double value);
+EXPORT int getOutputSupervisionBehavior(HSNMP session, int channel);
+EXPORT int setOutputSupervisionBehavior(HSNMP session, int channel, int value);
+EXPORT double getOutputSupervisionMinSenseVoltage(HSNMP session, int channel);
+EXPORT double setOutputSupervisionMinSenseVoltage(HSNMP session, int channel, double value);
+EXPORT double getOutputSupervisionMaxSenseVoltage(HSNMP session, int channel);
+EXPORT double setOutputSupervisionMaxSenseVoltage(HSNMP session, int channel, double value);
+EXPORT double getOutputSupervisionMaxTerminalVoltage(HSNMP session, int channel);
+EXPORT double setOutputSupervisionMaxTerminalVoltage(HSNMP session, int channel, double value);
+EXPORT double getOutputSupervisionMaxCurrent(HSNMP session, int channel);
+EXPORT double setOutputSupervisionMaxCurrent(HSNMP session, int channel, double value);
+EXPORT int setOutputSupervisionMaxTemperature(HSNMP session, int channel, int value);
+EXPORT double getOutputConfigMaxSenseVoltage(HSNMP session, int channel);
+EXPORT double getOutputConfigMaxTerminalVoltage(HSNMP session, int channel);
+EXPORT double getOutputConfigMaxCurrent(HSNMP session, int channel);
+EXPORT double getOutputSupervisionMaxPower(HSNMP session, int channel);
+EXPORT int getOutputTripTimeMaxCurrent(HSNMP session, int channel);
+EXPORT int setOutputTripTimeMaxCurrent(HSNMP session, int channel, int delay);
+
+//Sensor Information functions
+EXPORT int getSensorNumber(HSNMP session);
+EXPORT int getSensorTemp(HSNMP session, int sensor);
+EXPORT int getSensorWarningTemperature(HSNMP session, int sensor);
+EXPORT int setSensorWarningTemperature(HSNMP session, int sensor, int value);
+EXPORT int getSensorFailureTemperature(HSNMP session, int sensor);
+EXPORT int setSensorFailureTemperature(HSNMP session, int sensor, int value);
+
+//SNMP Community Name Functions
+//std::string getSnmpCommunityName(HSNMP session, int index);
+//std::string setSnmpCommunityName(HSNMP session, int index , int value);
+
+//Power Supply Detail Functions
+//std::string getPsFirmwareVersion(HSNMP session);
+//std::string getPsSerialNumber(HSNMP session);
+EXPORT int getPsOperatingTime(HSNMP session);
+EXPORT double getPsAuxVoltage(HSNMP session, int auxIndex);
+EXPORT double getPsAuxCurrent(HSNMP session, int auxIndex);
+//std::string getPsDirectAccess(HSNMP session);
+//std::string setPsDirectAccess(HSNMP session);
+
+//Fan Tray Functions
+//std::string getFanFirmwareVersion(HSNMP session);
+//std::string getFanSerialNumber(HSNMP session);
+EXPORT int getFanOperatingTime(HSNMP session);
+EXPORT int getFanAirTemperature(HSNMP session);
+EXPORT int getFanSwitchOffDelay(HSNMP session);
+EXPORT int setFanSwitchOffDelay(HSNMP session, int value);
+EXPORT int getFanNominalSpeed(HSNMP session);
+EXPORT int setFanNominalSpeed(HSNMP session, int value);
+EXPORT int getFanNumberOfFans(HSNMP session);
+EXPORT int getFanSpeed(HSNMP session, int fan);
+
+// Module functions
+EXPORT char *getModuleDescription(HSNMP session, int slot);
+EXPORT double getModuleSupply24(HSNMP session, int slot);
+EXPORT double getModuleSupply5(HSNMP session, int slot);
+EXPORT double getModuleAuxTemperature(HSNMP session, int slot, int index);
+EXPORT double getModuleHardwareLimitVoltage(HSNMP session, int slot);
+EXPORT double getModuleHardwareLimitCurrent(HSNMP session, int slot);
+EXPORT double getModuleRampSpeedVoltage(HSNMP session, int slot);
+EXPORT double setModuleRampSpeedVoltage(HSNMP session, int slot, double value);
+EXPORT double getModuleRampSpeedCurrent(HSNMP session, int slot);
+EXPORT double setModuleRampSpeedCurrent(HSNMP session, int slot, double value);
+EXPORT int getModuleStatus(HSNMP session, int slot);
+EXPORT int getModuleEventStatus(HSNMP session, int slot);
+EXPORT int setModuleDoClear(HSNMP session, int slot);
+
+/**
+ * @enum MaximumCrateValues
+ */
+typedef enum MaximumCrateValues {
+ MaxModuleAuxSupplies = 2, ///< The maximum number of module auxiliary supply measurements
+ MaxModuleAuxTemperatures = 4, ///< The maximum number of module temperature sensors (iseg HV only)
+ MaxCommunities = 4, ///< The maximum number of SNMP community names
+ MaxFans = 6,
+ MaxPsAuxSupplies = 8,
+ MaxSlotsPerCrate = 10, ///< The number of slots per crate
+ MaxSensors = 12, ///< The maximum
+ MaxChannelsPerSlot = 100, ///< The maximum number of channels per slot
+ MaxChannelsPerCrate = 1000 ///< The maximum number of channels per crate
+} MaximumCrateValues;
+
+/**
+ * @struct SnmpDoubleBuffer
+ * This struct is used to pass double parameters to setMultiple... functions
+ * and for the result value of getMultiple.../setMultiple... functions.
+ */
+typedef struct SnmpDoubleBuffer {
+ int size; ///< The number of values used in value[]
+ double value[MaxChannelsPerSlot]; ///< An array of max. 100 double values
+} SnmpDoubleBuffer;
+
+/**
+ * @struct SnmpIntegerBuffer
+ * This struct is used to pass integer parameters to setMultiple... functions
+ * and for the result value of getMultiple.../setMultiple... functions.
+*/
+typedef struct SnmpIntegerBuffer {
+ int size; ///< The number of values used in value[]
+ int value[MaxChannelsPerSlot]; ///< An array of max. 100 int values
+} SnmpIntegerBuffer;
+
+// Functions for multiple data transfer in one SNMP packet
+EXPORT SnmpIntegerBuffer *getMultipleChannelStatuses(HSNMP session, int start, int size);
+EXPORT SnmpIntegerBuffer *getMultipleOutputStatuses(HSNMP session, int start, int size);
+EXPORT SnmpIntegerBuffer *getMultipleOutputSwitches(HSNMP session, int start, int size);
+EXPORT SnmpIntegerBuffer *setMultipleOutputSwitches(HSNMP session, int start, SnmpIntegerBuffer *values);
+EXPORT SnmpDoubleBuffer *getMultipleOutputVoltages(HSNMP session, int start, int size);
+EXPORT SnmpDoubleBuffer *setMultipleOutputVoltages(HSNMP session, int start, SnmpDoubleBuffer *values);
+EXPORT SnmpDoubleBuffer *getMultipleMeasurementTerminalVoltages(HSNMP session, int start, int size);
+EXPORT SnmpDoubleBuffer *getMultipleOutputMeasurementTerminalVoltages(HSNMP session, int start, int size);
+EXPORT SnmpDoubleBuffer *getMultipleOutputConfigMaxTerminalVoltages(HSNMP session, int start, int size);
+EXPORT SnmpDoubleBuffer *getMultipleOutputCurrents(HSNMP session, int start, int size);
+EXPORT SnmpDoubleBuffer *setMultipleOutputCurrents(HSNMP session, int start, SnmpDoubleBuffer *values);
+EXPORT SnmpDoubleBuffer *getMultipleMeasurementCurrents(HSNMP session, int start, int size);
+EXPORT SnmpDoubleBuffer *getMultipleOutputMeasurementCurrents(HSNMP session, int start, int size);
+EXPORT SnmpDoubleBuffer *getMultipleOutputConfigMaxCurrents(HSNMP session, int start, int size);
+EXPORT SnmpIntegerBuffer *getMultipleOutputTripTimeMaxCurrents(HSNMP session, int start, int size);
+EXPORT SnmpIntegerBuffer *setMultipleOutputTripTimeMaxCurrents(HSNMP session, int start, SnmpIntegerBuffer *values);
+EXPORT SnmpIntegerBuffer *getMultipleOutputSupervisionBehaviors(HSNMP session, int start, int size);
+EXPORT SnmpIntegerBuffer *setMultipleOutputSupervisionBehaviors(HSNMP session, int start, SnmpIntegerBuffer *values);
+//************************************************************
+#define MAX_CRATES 10
+
+extern HSNMP crateHsnmp[MAX_CRATES];
+
+int _VI_FUNC MPOD_Start (void);
+
+int _VI_FUNC MPOD_Open (int mpodn, char *address);
+
+int _VI_FUNC MPOD_GetInt (int mpodn, char *oidstr);
+
+int _VI_FUNC MPOD_SetInt (int mpodn, char *oidstr, int iset);
+
+double _VI_FUNC MPOD_GetDouble (int mpodn, char *oidstr);
+
+double _VI_FUNC MPOD_SetDouble (int mpodn, char *oidstr, double dset);
+
+int _VI_FUNC MPOD_GetIntCh (int mpodn, char *oidstrbase, int ich);
+
+int _VI_FUNC MPOD_SetIntCh (int mpodn, char *oidstrbase, int ich, int iset);
+
+double _VI_FUNC MPOD_GetDoubleCh (int mpodn, char *oidstrbase, int ich);
+
+double _VI_FUNC MPOD_SetDoubleCh (int mpodn, char *oidstrbase, int ich,
+ double dset);
+
+int _VI_FUNC MPOD_Close (int mpodn);
+
+int _VI_FUNC MPOD_End (void);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __MPOD_H__ */
Index: instr/MPOD/MPOD.prj
===================================================================
--- instr/MPOD/MPOD.prj (revision 154)
+++ instr/MPOD/MPOD.prj (revision 155)
@@ -9,7 +9,7 @@
VXIplug&play Framework Dir = "/C/Program Files (x86)/IVI Foundation/VISA/winnt"
IVI Standard Root 64-bit Dir = "/C/Program Files/IVI Foundation/IVI"
VXIplug&play Framework 64-bit Dir = "/C/Program Files/IVI Foundation/VISA/win64"
-Number of Files = 7
+Number of Files = 5
Target Type = "Executable"
Flags = 2064
Copied From Locked InstrDrv Directory = False
@@ -42,23 +42,10 @@
Folder Id = 0
[File 0002]
-File Type = "CSource"
+File Type = "Include"
Res Id = 2
Path Is Rel = True
Path Rel To = "Project"
-Path Rel Path = "WIENER_SNMP.c"
-Path = "/c/SAMO/Programi/NI/cvi/instr/MPOD/WIENER_SNMP.c"
-Exclude = False
-Compile Into Object File = False
-Project Flags = 0
-Folder = "Source Files"
-Folder Id = 0
-
-[File 0003]
-File Type = "Include"
-Res Id = 3
-Path Is Rel = True
-Path Rel To = "Project"
Path Rel Path = "MPOD.h"
Path = "/c/SAMO/Programi/NI/cvi/instr/MPOD/MPOD.h"
Exclude = False
@@ -66,9 +53,9 @@
Folder = "Include Files"
Folder Id = 1
-[File 0004]
+[File 0003]
File Type = "Include"
-Res Id = 4
+Res Id = 3
Path Is Rel = True
Path Rel To = "Project"
Path Rel Path = "net-snmp-config.h"
@@ -78,21 +65,9 @@
Folder = "Include Files"
Folder Id = 1
-[File 0005]
-File Type = "Include"
-Res Id = 5
-Path Is Rel = True
-Path Rel To = "Project"
-Path Rel Path = "WIENER_SNMP.h"
-Path = "/c/SAMO/Programi/NI/cvi/instr/MPOD/WIENER_SNMP.h"
-Exclude = False
-Project Flags = 0
-Folder = "Include Files"
-Folder Id = 1
-
-[File 0006]
+[File 0004]
File Type = "Library"
-Res Id = 6
+Res Id = 4
Path Is Rel = True
Path Rel To = "Project"
Path Rel Path = "../../../../../../usr/lib/netsnmp.lib"
@@ -102,9 +77,9 @@
Folder = "Library Files"
Folder Id = 2
-[File 0007]
+[File 0005]
File Type = "Function Panel"
-Res Id = 7
+Res Id = 5
Path Is Rel = True
Path Rel To = "Project"
Path Rel Path = "MPOD.fp"
/cvi/instr/MPOD/WIENER_SNMP.c
127,9 → 127,9
 
//static double snmpSetDouble(HSNMP session, const SnmpObject &object, double value);
static double snmpSetDouble(HSNMP session, const SnmpObject *object, double value);
double snmpGetDouble(HSNMP session, const SnmpObject *object);
static double snmpGetDouble(HSNMP session, const SnmpObject *object);
static int snmpSetInt(HSNMP session, const SnmpObject *object, int value);
int snmpGetInt(HSNMP session, const SnmpObject *object);
static int snmpGetInt(HSNMP session, const SnmpObject *object);
static char *snmpGetString(HSNMP session, const SnmpObject *object);
 
char snmpStringBuffer[1024];
184,7 → 184,7
* @return true on success, false otherwise
*/
//static int getNode(const char * const node, SnmpObject *object)
int getNode(const char * const node, SnmpObject *object)
static int getNode(const char * const node, SnmpObject *object)
{
object->len = MAX_OID_LEN;
if (!get_node(node, object->id, &object->len)) {
1744,7 → 1744,7
return pdu;
}
 
int snmpGetInt(HSNMP session, const SnmpObject *object)
static int snmpGetInt(HSNMP session, const SnmpObject *object)
{
int value = 0;
 
1790,7 → 1790,7
return result;
}
 
double snmpGetDouble(HSNMP session, const SnmpObject *object)
static double snmpGetDouble(HSNMP session, const SnmpObject *object)
{
double value = 0.0;
 
/cvi/instr/MPOD/WIENER_SNMP.h
1,5 → 1,3
/** @file */
 
#ifndef WIENER_SNMP_H
#define WIENER_SNMP_H