WebSVN – f9daq – Blame – /cvi/instr/MPOD/WIENER_SNMP.c

Rev	Author	Line No.	Line
151	f9daq	1	// WIENER SNMP basic SNMP library to Demonstrate C-Access to WIENER-Crates via SNMP
		2	// modified for LabView import 04/23/06, Andreas Ruben
		3	//
		4	// The path to the Net-SNMP include files (default /usr/include) must be added to the
		5	// include file search path!
		6	// The following libraries must be included:
		7	// netsnmp.lib ws2_32.lib
		8	// The path to the Net-SNMP library must be added to the linker files.
		9	// /usr/lib
		10	// path for the WIENER MIB file (mibdirs) c:/usr/share/snmp/mibs
		11
		12	#include <windows.h>
		13	#include "toolbox.h"
		14	#include <ansi_c.h>
		15	#include "WIENER_SNMP.h"
		16
		17	#define VER_FILEVERSION 1,1,1,0
		18	#define VER_FILEVERSION_STR "1.1.1.0\0"
		19
		20	#ifdef _MSC_VER
		21	#define strdup _strdup
		22	#define vsnprintf vsprintf_s
		23	#define strPrintf sprintf_s
		24	#else
		25	#define strdup StrDup
		26	#define strPrintf snprintf
		27	#endif
		28
		29	#ifndef UNREFERENCED_PARAMETER
		30	#define UNREFERENCED_PARAMETER(P) (void)(P)
		31	#endif
		32
		33	#define false 0;
		34	#define true 1;
		35
		36
		37	static const char WienerMibFileName[] = "WIENER-CRATE-MIB";
		38	static const char DefaultReadCommunity[] = "public"; ///< default community name for read operations
		39	static const char DefaultWriteCommunity[] = "guru"; ///< default community name for write operation
		40
		41	static char m_readCommunity = (char )DefaultReadCommunity;
		42	static char m_writeCommunity = (char )DefaultWriteCommunity;
		43
		44	/**
		45	* @brief The SnmpObject class is used internally to resolve OIDs and for the SNMP calls.
		46	*/
		47	//class SnmpObject {
		48	//public:
		49	typedef struct {
		50	oid id[MAX_OID_LEN]; ///< The resolved SNMP OID
		51	size_t len; ///< The resolved OIDs length in byte
		52	char desc[100]; ///< The OIDs textual representation, e.g. "sysDescr.0"
		53	} SnmpObject;
		54	//typedef struct snmp_object SnmpObject;
		55
		56	static SnmpObject moduleIndex[MaxSlotsPerCrate];
		57	static SnmpObject moduleDescription[MaxSlotsPerCrate];
		58	static SnmpObject moduleSupply[MaxModuleAuxSupplies][MaxSlotsPerCrate];
		59	static SnmpObject moduleHardwareLimitVoltage[MaxSlotsPerCrate];
		60	static SnmpObject moduleHardwareLimitCurrent[MaxSlotsPerCrate];
		61	static SnmpObject moduleRampSpeedVoltage[MaxSlotsPerCrate];
		62	static SnmpObject moduleRampSpeedCurrent[MaxSlotsPerCrate];
		63	static SnmpObject moduleStatus[MaxSlotsPerCrate];
		64	static SnmpObject moduleEventStatus[MaxSlotsPerCrate];
		65	static SnmpObject moduleDoClear[MaxSlotsPerCrate];
		66	static SnmpObject moduleAuxiliaryMeasurementTemperature[MaxModuleAuxTemperatures][MaxSlotsPerCrate];
		67
		68	static SnmpObject sysDescr;
		69	static SnmpObject sysMainSwitch;
		70	static SnmpObject sysStatus;
		71	static SnmpObject sysVmeSysReset;
		72	static SnmpObject outputNumber;
		73	static SnmpObject groupsNumber;
		74	static SnmpObject highVoltageGroupsSwitch;
		75	static SnmpObject lowVoltageGroupsSwitch;
		76	static SnmpObject ipStaticAddress;
		77
		78	static SnmpObject outputName[MaxChannelsPerCrate];
		79	static SnmpObject outputIndex[MaxChannelsPerCrate];
		80	static SnmpObject outputGroup[MaxChannelsPerCrate];
		81	static SnmpObject outputStatus[MaxChannelsPerCrate];
		82	static SnmpObject outputMeasurementSenseVoltage[MaxChannelsPerCrate];
		83	static SnmpObject outputMeasurementTerminalVoltage[MaxChannelsPerCrate];
		84	static SnmpObject outputMeasurementCurrent[MaxChannelsPerCrate];
		85	static SnmpObject outputMeasurementTemperature[MaxChannelsPerCrate];
		86	static SnmpObject outputSwitch[MaxChannelsPerCrate];
		87	static SnmpObject outputVoltage[MaxChannelsPerCrate];
		88	static SnmpObject outputCurrent[MaxChannelsPerCrate];
		89	static SnmpObject outputVoltageRiseRate[MaxChannelsPerCrate];
		90	static SnmpObject outputVoltageFallRate[MaxChannelsPerCrate];
		91	static SnmpObject outputCurrentRiseRate[MaxChannelsPerCrate];
		92	static SnmpObject outputCurrentFallRate[MaxChannelsPerCrate];
		93	static SnmpObject outputSupervisionBehavior[MaxChannelsPerCrate];
		94	static SnmpObject outputSupervisionMinSenseVoltage[MaxChannelsPerCrate];
		95	static SnmpObject outputSupervisionMaxSenseVoltage[MaxChannelsPerCrate];
		96	static SnmpObject outputSupervisionMaxTerminalVoltage[MaxChannelsPerCrate];
		97	static SnmpObject outputSupervisionMaxCurrent[MaxChannelsPerCrate];
		98	static SnmpObject outputSupervisionMaxTemperature[MaxChannelsPerCrate];
		99	static SnmpObject outputConfigMaxSenseVoltage[MaxChannelsPerCrate];
		100	static SnmpObject outputConfigMaxTerminalVoltage[MaxChannelsPerCrate];
		101	static SnmpObject outputConfigMaxCurrent[MaxChannelsPerCrate];
		102	static SnmpObject outputSupervisionMaxPower[MaxChannelsPerCrate];
		103	static SnmpObject outputTripTimeMaxCurrent[MaxChannelsPerCrate];
		104
		105	static SnmpObject sensorNumber;
		106	static SnmpObject sensorTemperature[MaxSensors];
		107	static SnmpObject sensorWarningThreshold[MaxSensors];
		108	static SnmpObject sensorFailureThreshold[MaxSensors];
		109
		110	//static SnmpObject psFirmwareVersion;
		111	static SnmpObject psSerialNumber;
		112	static SnmpObject psOperatingTime;
		113	static SnmpObject psDirectAccess;
		114	static SnmpObject fanNumberOfFans;
		115	static SnmpObject fanOperatingTime;
		116	//static SnmpObject fanFirmwareVersion;
		117	static SnmpObject fanSerialNumber;
		118	static SnmpObject fanAirTemperature;
		119	static SnmpObject fanSwitchOffDelay;
		120	static SnmpObject fanNominalSpeed;
		121	static SnmpObject fanSpeed[MaxFans];
		122
		123	static SnmpObject psAuxVoltage[MaxPsAuxSupplies];
		124	static SnmpObject psAuxCurrent[MaxPsAuxSupplies];
		125
		126	static SnmpObject snmpCommunityName[MaxCommunities];
		127
		128	//static double snmpSetDouble(HSNMP session, const SnmpObject &object, double value);
		129	static double snmpSetDouble(HSNMP session, const SnmpObject *object, double value);
		130	static double snmpGetDouble(HSNMP session, const SnmpObject *object);
		131	static int snmpSetInt(HSNMP session, const SnmpObject *object, int value);
		132	static int snmpGetInt(HSNMP session, const SnmpObject *object);
		133	static char snmpGetString(HSNMP session, const SnmpObject object);
		134
		135	char snmpStringBuffer[1024];
		136	char snmpLastErrorBuffer[1024];
		137
		138	SnmpDoubleBuffer snmpDoubleBuffer;
		139	SnmpIntegerBuffer snmpIntegerBuffer;
		140
		141	#ifdef _MSC_VER
		142
		143	BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
		144	{
		145	UNREFERENCED_PARAMETER(hModule);
		146	UNREFERENCED_PARAMETER(ul_reason_for_call);
		147	UNREFERENCED_PARAMETER(lpReserved);
		148
		149	return TRUE;
		150	}
		151
		152	#endif
		153
		154	/**
		155	* @brief Simple logging function with printf-like usage.
		156	* @internal
		157	* @param priority
		158	* @param format
		159	*/
		160	static void sysLog(int priority, const char *format, ...)
		161	{
		162	UNREFERENCED_PARAMETER(priority);
		163
		164	va_list vaPrintf;
		165	va_start(vaPrintf, format);
		166	vprintf(format, vaPrintf);
		167	putchar('\n');
		168
		169	// store errors in snmpLastErrorBuffer, which can be read by snmpGetLastError()
		170	if (priority == LOG_ERR)
		171	vsnprintf(snmpLastErrorBuffer, sizeof(snmpLastErrorBuffer), format, vaPrintf);
		172
		173	va_end(vaPrintf);
		174	}
		175
		176	// Helper functions
		177
		178	/**
		179	* @brief Resolves the OID from the textual SNMP description
		180	* and stores the OID in *object.
		181	* @internal
		182	* @param node e.g. "sysMainSwitch"
		183	* @param object the resolved OID
		184	* @return true on success, false otherwise
		185	*/
		186	static int getNode(const char * const node, SnmpObject *object)
		187	{
		188	object->len = MAX_OID_LEN;
		189	if (!get_node(node, object->id, &object->len)) {
		190	snmp_log(LOG_ERR, "OID %s not found!\n", node);
		191	return false;
		192	}
		193
		194	#ifdef _MSC_VER
		195	strcpy_s(object->desc, sizeof(object->desc), node);
		196	#else
		197	strncpy(object->desc, node, sizeof(object->desc));
		198	#endif
		199
		200	return true;
		201	}
		202
		203	/**
		204	* @brief Resolves the OID from the textual SNMP description
		205	* with appended index and stores the OID in *object.
		206	* @internal
		207	* @param nodeBase e.g. "outputSwitch"
		208	* @param index e.g. 100
		209	* @param object the resolved OID
		210	* @return true on success, false otherwise
		211	*/
		212	static int getIndexNode(const char * const nodeBase, int index, SnmpObject *object)
		213	{
		214	char node[100];
		215
		216	strPrintf(node, sizeof(node), "%s.%i", nodeBase, index);
		217
		218	return getNode(node, object);
		219	}
		220
		221	/**
		222	* @brief Activates logging on stderr console.
		223	* @since 1.1
		224	* @note This is the default setting.
		225	*/
		226	void snmpSetStdErrLog(void)
		227	{
		228	snmp_enable_stderrlog();
		229	}
		230
		231	/**
		232	* @brief Activates logging to the file filename.
		233	* @since 1.1
		234	* @param fileName The full path to the file where all log
		235	* information should go to.
		236	* @note If the specified file already exists,
		237	* new log information is appended.
		238	*/
		239	void snmpSetFileLog(const char * const fileName)
		240	{
		241	snmp_enable_filelog(fileName, 1);
		242	}
		243
		244	/**
		245	* @brief Returns the library four digit version number as unsigned int value.
		246	*
		247	* This allows to check for a specific version number.
		248	* @since 1.1
		249	* @return The version number as unsigned long value, e.g. 0x01010000
		250	*/
		251	unsigned int snmpGetVersion(void)
		252	{
		253	const uint32_t version[] = { VER_FILEVERSION };
		254
		255	return (version[0] << 24) + (version[1] << 16) + (version[2] << 8) + version[3];
		256	}
		257
		258	/**
		259	* @brief Returns the library four digit version number as null-terminated string.
		260	*
		261	* The digits are separated by dots.
		262	* @since 1.1
		263	* @return The version number, e.g. "1.1.0.3"
		264	*/
		265	char *snmpGetVersionString(void)
		266	{
		267	return VER_FILEVERSION_STR;
		268	}
		269
		270	/**
		271	* @brief Setup the default conditions for logging and SNMP passwords.
		272	* @internal
		273	*/
		274	static void setDefaultSettings(void)
		275	{
		276	snmpSetStdErrLog();
		277
		278	m_readCommunity = (char *)DefaultReadCommunity;
		279	m_writeCommunity = (char *)DefaultWriteCommunity;
		280
		281	memset(snmpLastErrorBuffer, 0, sizeof(snmpLastErrorBuffer));
		282	}
		283
		284	/**
		285	* @brief SNMP Initialization.
		286	*
		287	* Resolves all needed OIDs from the MIB file and prepares the SNMP communication.
		288	* The actual connection to a MPOD crate is done with snmpOpen().
		289	* @return true on success, false otherwise (e.g. an OID could not be resolved)
		290	*/
		291	int snmpInit(void)
		292	{
		293	setDefaultSettings();
		294
		295	snmp_log(LOG_DEBUG, "* Initialise SNMP *\n");
		296
		297	init_snmp("WIENER_SNMP_DLL");
		298	init_mib(); // init MIB processing
		299	if (!read_module(WienerMibFileName)) { // read specific mibs
		300	snmp_log(LOG_ERR, "Unable to load SNMP MIB file \"%s\"\n", WienerMibFileName);
		301	return false;
		302	}
		303	snmp_log(LOG_DEBUG, "* Translate OIDs *\n");
		304
		305	// Translate System OIDS
		306	getNode("sysDescr.0", &sysDescr); // FIXME: doesn't work atm in Linux
		307
		308	if (
		309	(!getNode("sysMainSwitch.0", &sysMainSwitch)) \|\|
		310	(!getNode("sysStatus.0", &sysStatus)) \|\|
		311	(!getNode("sysVmeSysReset.0", &sysVmeSysReset)) \|\|
		312	(!getNode("outputNumber.0", &outputNumber)) \|\|
		313	(!getNode("groupsNumber.0", &groupsNumber)) \|\|
		314	(!getNode("groupsSwitch.64", &highVoltageGroupsSwitch)) \|\|
		315	(!getNode("groupsSwitch.128", &lowVoltageGroupsSwitch)) \|\|
		316	(!getNode("ipStaticAddress.0", &ipStaticAddress)) \|\|
		317	// (!getNode("psFirmwareVersion.0", &psFirmwareVersion)) \|\|
		318	(!getNode("psSerialNumber.0", &psSerialNumber)) \|\|
		319	(!getNode("psOperatingTime.0", &psOperatingTime)) \|\|
		320	(!getNode("psDirectAccess.0", &psDirectAccess)) \|\|
		321	(!getNode("sensorNumber.0", &sensorNumber)) \|\|
		322	// (!getNode("fanFirmwareVersion.0", &fanFirmwareVersion)) \|\|
		323	(!getNode("fanSerialNumber.0", &fanSerialNumber)) \|\|
		324	(!getNode("fanOperatingTime.0", &fanOperatingTime)) \|\|
		325	(!getNode("fanAirTemperature.0", &fanAirTemperature))\|\|
		326	(!getNode("fanSwitchOffDelay.0", &fanSwitchOffDelay)) \|\|
		327	(!getNode("fanNominalSpeed.0", &fanNominalSpeed)) \|\|
		328	(!getNode("fanNumberOfFans.0", &fanNumberOfFans))
		329	) {
		330	return false;
		331	}
		332
		333	// Translate module and channel information OIDs
		334	for (int slot = 0; slot < MaxSlotsPerCrate; ++slot) {
		335
		336	if (
		337	(!getIndexNode("moduleIndex", slot + 1, &moduleIndex[slot])) \|\|
		338	(!getIndexNode("moduleDescription", slot + 1, &moduleDescription[slot])) \|\|
		339	(!getIndexNode("moduleAuxiliaryMeasurementVoltage0", slot + 1, &moduleSupply[0][slot])) \|\|
		340	(!getIndexNode("moduleAuxiliaryMeasurementVoltage1", slot + 1, &moduleSupply[1][slot])) \|\|
		341	(!getIndexNode("moduleAuxiliaryMeasurementTemperature0", slot + 1, &moduleAuxiliaryMeasurementTemperature[0][slot])) \|\|
		342	(!getIndexNode("moduleAuxiliaryMeasurementTemperature1", slot + 1, &moduleAuxiliaryMeasurementTemperature[1][slot])) \|\|
		343	(!getIndexNode("moduleAuxiliaryMeasurementTemperature2", slot + 1, &moduleAuxiliaryMeasurementTemperature[2][slot])) \|\|
		344	(!getIndexNode("moduleAuxiliaryMeasurementTemperature3", slot + 1, &moduleAuxiliaryMeasurementTemperature[3][slot])) \|\|
		345	(!getIndexNode("moduleHardwareLimitVoltage", slot + 1, &moduleHardwareLimitVoltage[slot])) \|\|
		346	(!getIndexNode("moduleHardwareLimitCurrent", slot + 1, &moduleHardwareLimitCurrent[slot])) \|\|
		347	(!getIndexNode("moduleRampSpeedVoltage", slot + 1, &moduleRampSpeedVoltage[slot])) \|\|
		348	(!getIndexNode("moduleRampSpeedCurrent", slot + 1, &moduleRampSpeedCurrent[slot])) \|\|
		349	(!getIndexNode("moduleStatus", slot + 1, &moduleStatus[slot])) \|\|
		350	(!getIndexNode("moduleEventStatus", slot + 1, &moduleEventStatus[slot])) \|\|
		351	(!getIndexNode("moduleDoClear", slot + 1, &moduleDoClear[slot]))
		352	) {
		353	return false;
		354	}
		355
		356	int base = MaxChannelsPerSlot * slot; // array index
		357
		358	for (int channel = base; channel < base + MaxChannelsPerSlot; ++channel) {
		359	if (
		360	(!getIndexNode("outputName", channel + 1, &outputName[channel])) \|\|
		361	(!getIndexNode("outputIndex", channel + 1, &outputIndex[channel])) \|\|
		362	(!getIndexNode("outputGroup", channel + 1, &outputGroup[channel])) \|\|
		363	(!getIndexNode("outputStatus", channel + 1, &outputStatus[channel])) \|\|
		364	(!getIndexNode("outputMeasurementSenseVoltage", channel + 1, &outputMeasurementSenseVoltage[channel])) \|\|
		365	(!getIndexNode("outputMeasurementTerminalVoltage", channel + 1, &outputMeasurementTerminalVoltage[channel])) \|\|
		366	(!getIndexNode("outputMeasurementCurrent", channel + 1, &outputMeasurementCurrent[channel])) \|\|
		367	(!getIndexNode("outputMeasurementTemperature", channel + 1, &outputMeasurementTemperature[channel])) \|\|
		368	(!getIndexNode("outputSwitch", channel + 1, &outputSwitch[channel])) \|\|
		369	(!getIndexNode("outputVoltage", channel + 1, &outputVoltage[channel])) \|\|
		370	(!getIndexNode("outputCurrent", channel + 1, &outputCurrent[channel])) \|\|
		371	(!getIndexNode("outputVoltageRiseRate", channel + 1, &outputVoltageRiseRate[channel])) \|\|
		372	(!getIndexNode("outputVoltageFallRate", channel + 1, &outputVoltageFallRate[channel])) \|\|
		373	(!getIndexNode("outputCurrentRiseRate", channel + 1, &outputCurrentRiseRate[channel])) \|\|
		374	(!getIndexNode("outputCurrentFallRate", channel + 1, &outputCurrentFallRate[channel])) \|\|
		375	(!getIndexNode("outputSupervisionBehavior", channel + 1, &outputSupervisionBehavior[channel])) \|\|
		376	(!getIndexNode("outputSupervisionMinSenseVoltage", channel + 1, &outputSupervisionMinSenseVoltage[channel])) \|\|
		377	(!getIndexNode("outputSupervisionMaxSenseVoltage", channel + 1, &outputSupervisionMaxSenseVoltage[channel])) \|\|
		378	(!getIndexNode("outputSupervisionMaxTerminalVoltage", channel + 1, &outputSupervisionMaxTerminalVoltage[channel])) \|\|
		379	(!getIndexNode("outputSupervisionMaxCurrent", channel + 1, &outputSupervisionMaxCurrent[channel])) \|\|
		380	// (!getIndexNode("outputSupervisionMaxTemperature", channel + 1, &outputSupervisionMaxTemperature[channel])) \|\|
		381	(!getIndexNode("outputConfigMaxSenseVoltage", channel + 1, &outputConfigMaxSenseVoltage[channel])) \|\|
		382	(!getIndexNode("outputConfigMaxTerminalVoltage", channel + 1, &outputConfigMaxTerminalVoltage[channel])) \|\|
		383	(!getIndexNode("outputSupervisionMaxPower", channel + 1, &outputSupervisionMaxPower[channel])) \|\|
		384	(!getIndexNode("outputConfigMaxCurrent", channel + 1, &outputConfigMaxCurrent[channel])) \|\|
		385	(!getIndexNode("outputTripTimeMaxCurrent", channel + 1, &outputTripTimeMaxCurrent[channel]))
		386	) {
		387	return false;
		388	}
		389	}
		390	}
		391
		392	for (int sensor = 0; sensor < MaxSensors; ++sensor)
		393	if (
		394	(!getIndexNode("sensorTemperature", sensor + 1, &sensorTemperature[sensor])) \|\|
		395	(!getIndexNode("sensorWarningThreshold", sensor + 1, &sensorWarningThreshold[sensor])) \|\|
		396	(!getIndexNode("sensorFailureThreshold", sensor + 1, &sensorFailureThreshold[sensor]))
		397	) {
		398	return false;
		399	}
		400
		401	for (int name = 0; name < MaxCommunities; ++name)
		402	if (!getIndexNode("snmpCommunityName", name + 1, &snmpCommunityName[name]))
		403	return false;
		404
		405	for (int fan = 0; fan < MaxFans; ++fan)
		406	if (!getIndexNode("fanSpeed", fan + 1, &fanSpeed[fan]))
		407	return false;
		408
		409	for (int aux = 0; aux < MaxPsAuxSupplies; ++aux) {
		410	if (
		411	(!getIndexNode("psAuxiliaryMeasurementVoltage", aux + 1, &psAuxVoltage[aux])) \|\|
		412	(!getIndexNode("psAuxiliaryMeasurementCurrent", aux + 1, &psAuxCurrent[aux]))
		413	) {
		414	return false;
		415	}
		416	}
		417
		418	snmp_log(LOG_DEBUG, "* Initialise SNMP done *\n");
		419	SOCK_STARTUP; // only in main thread
		420
		421	return true;
		422	}
		423
		424	/**
		425	* @brief Additional cleanup. Should be called after snmpClose.
		426	*/
		427	void snmpCleanup(void)
		428	{
		429	SOCK_CLEANUP;
		430	}
		431
		432	/**
		433	* @brief Set a new read community name for SNMP access.
		434	*
		435	* The read community name has to match the configured read community name in the MPOD.
		436	* The default read community name is "public".
		437	* @since 1.1
		438	* @note This function must be called before snmpOpen().
		439	* @param readCommunityName the new read community name
		440	*/
		441	void snmpSetReadCommunityName(const char * const readCommunityName)
		442	{
		443	m_readCommunity = strdup(readCommunityName);
		444	}
		445
		446	/**
		447	* @brief Set a new write community name for SNMP access.
		448	*
		449	* The write community name has to match the configured write community name in the MPOD.
		450	* The default write community name is "guru".
		451	* @since 1.1
		452	* @note This function must be called before any write access function.
		453	* @param writeCommunityName the new write community name
		454	*/
		455	void snmpSetWriteCommunityName(const char * const writeCommunityName)
		456	{
		457	m_writeCommunity = strdup(writeCommunityName);
		458	}
		459
		460	/**
		461	* @brief Opens a SNMP session to the specified ipAddress.
		462	*
		463	* This function also sets the number of retries and the timeout value.
		464	* @param ipAddress a zero-terminated ASCII string representation
		465	* of an IPv4 address, e.g. "192.168.17.101"
		466	* @return a handle to the opened SNMP session, which is a required
		467	* parameter for any further call.
		468	*/
		469	HSNMP snmpOpen(const char * const ipAddress)
		470	{
		471	HSNMP session;
		472	struct snmp_session snmpSession;
		473	snmp_sess_init(&snmpSession); // structure defaults
		474	snmpSession.version = SNMP_VERSION_2c;
		475	snmpSession.peername = strdup(ipAddress);
		476	snmpSession.community = (u_char *)strdup(m_readCommunity);
		477	snmpSession.community_len = strlen(m_readCommunity);
		478
		479	snmpSession.timeout = 300000; // timeout (us)
		480	snmpSession.retries = 2; // retries
		481
		482	if (!(session = snmp_sess_open(&snmpSession))) {
		483	int liberr, syserr;
		484	char *errstr;
		485	snmp_error(&snmpSession, &liberr, &syserr, &errstr);
		486	snmp_log(LOG_ERR, "Open SNMP session for host \"%s\": %s\n", ipAddress, errstr);
		487	free(errstr);
		488	return 0;
		489	}
		490
		491	snmp_log(LOG_INFO, "SNMP session for host \"%s\" opened\n", ipAddress);
		492	return session;
		493	}
		494
		495	/**
		496	* @brief Closes the previously opened session specified by session.
		497	* @param session The handle returned by snmpOpen()
		498	*/
		499	void snmpClose(HSNMP session)
		500	{
		501	if (!session)
		502	return;
		503
		504	if (!snmp_sess_close(session))
		505	snmp_log(LOG_ERR, "Close SNMP session: ERROR\n");
		506	else
		507	snmp_log(LOG_INFO, "SNMP session closed\n");
		508	}
		509
		510	/**
		511	* @brief Returns a pointer to a descriptive string for the last failed SNMP operation.
		512	* @return a pointer to a zero-terminated error string for the last failed
		513	* SNMP operation. Note: this pointer is valid until the next string operation.
		514	*/
		515	char *snmpGetLastError(void)
		516	{
		517	return snmpLastErrorBuffer;
		518	}
		519
		520	// System Information Functions
		521
		522	/**
		523	* @brief Returns a pointer to the MPOD controller description string.
		524	*
		525	* The pointer is valid until the next call of any string function.
		526	* @param session The handle returned by snmpOpen()
		527	* @return the MPOD controller description string, containing the
		528	* controller serial number and firmware releases, e.g.:
		529	* "WIENER MPOD (4388090, MPOD 2.1.2098.1, MPODslave 1.09, MPOD-BL 1.50 )"
		530	*/
		531	char *getSysDescr(HSNMP session)
		532	{
		533	return snmpGetString(session, &sysDescr);
		534	}
		535
		536	/**
		537	* @brief Returns the crate power on/off status.
		538	*
		539	* The result is the logical "and" between the hardware main switch
		540	* and the setMainSwitch function.
		541	* @param session The handle returned by snmpOpen()
		542	* @return The current on/off status of the crate:
		543	* 0: crate is powered off
		544	* 1: crate is powered on
		545	*/
		546	int getMainSwitch(HSNMP session)
		547	{
		548	return snmpGetInt(session, &sysMainSwitch);
		549	}
		550
		551	/**
		552	* @brief Sets the crate main switch to 1 = on or 0 = off.
		553	*
		554	* If the hardware main switch is set to "0" position, this function always returns 0.
		555	* @param session The handle returned by snmpOpen()
		556	* @param value 0 = set off, 1 = set on
		557	* @return The new on/off status of the crate.
		558	*/
		559	int setMainSwitch(HSNMP session, int value)
		560	{
		561	return snmpSetInt(session, &sysMainSwitch, value);
		562	}
		563
		564	/**
		565	* @brief Returns a bit field with the status of the complete crate.
		566	* @param session The handle returned by snmpOpen()
		567	* @return The complete crate status.
		568	*/
		569	int getMainStatus(HSNMP session)
		570	{
		571	return snmpGetInt(session, &sysStatus);
		572	}
		573
		574	/**
		575	* @brief Returns the VME system reset status.
		576	* @param session The handle returned by snmpOpen()
		577	* @return
		578	*/
		579	int getVmeReset(HSNMP session)
		580	{
		581	return snmpGetInt(session, &sysVmeSysReset);
		582	}
		583
		584	/**
		585	* @brief Initiate a VME system reset.
		586	* @param session The handle returned by snmpOpen()
		587	* @return
		588	*/
		589	int setVmeReset(HSNMP session)
		590	{
		591	return snmpSetInt(session, &sysVmeSysReset, 1);
		592	}
		593
		594	/**
		595	* @brief Returns the static IP address as 32 bit integer.
		596	* @param session The handle returned by snmpOpen()
		597	* @return The static IP address.
		598	*/
		599	int getIpStaticAddress(HSNMP session)
		600	{
		601	return snmpGetInt(session, &ipStaticAddress);
		602	}
		603
		604	/**
		605	* @brief Sets a new static IP address.
		606	* @param session The handle returned by snmpOpen()
		607	* @param value The IP address as 32 bit integer
		608	* @return
		609	*/
		610	int setIpStaticAddress(HSNMP session, int value)
		611	{
		612	return snmpSetInt(session, &ipStaticAddress, value);
		613	}
		614
		615	/**
		616	* @brief Returns a pointer to a string containing the MPOD controllers serial number.
		617	*
		618	* The pointer is valid until the next call of any string function.
		619	* @param session The handle returned by snmpOpen()
		620	* @return The crates serial number, e.g. "4388090".
		621	*/
		622	char *getPsSerialNumber(HSNMP session)
		623	{
		624	return snmpGetString(session, &psSerialNumber);
		625	}
		626
		627	// System Count Functions
		628
		629	/**
		630	* @brief Returns the total number of output channels in the crate.
		631	* @param session The handle returned by snmpOpen()
		632	* @return The total number of output channels
		633	*/
		634	int getOutputNumber(HSNMP session)
		635	{
		636	return snmpGetInt(session, &outputNumber);
		637	}
		638
		639	/**
		640	* @brief getOutputGroups
		641	* @param session The handle returned by snmpOpen()
		642	* @return
		643	*/
		644	int getOutputGroups(HSNMP session)
		645	{
		646	return snmpGetInt(session, &groupsNumber);
		647	}
		648
		649	// Output Channel Information
		650
		651	/**
		652	* @brief getOutputGroup
		653	* @param session The handle returned by snmpOpen()
		654	* @param channel The requested channel in the range of 0...999
		655	* @return
		656	*/
		657	int getOutputGroup(HSNMP session, int channel)
		658	{
		659	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		660	return 0;
		661
		662	return snmpGetInt(session, &outputGroup[channel]);
		663	}
		664
		665	/**
		666	* @brief Returns the channel outputStatus register.
		667	* @note This function is deprecated. Use getOutputStatus() instead.
		668	* @param session The handle returned by snmpOpen()
		669	* @param channel The requested channel in the range of 0...999
		670	* @return The channels outputStatus register
		671	*/
		672	int getChannelStatus(HSNMP session, int channel)
		673	{
		674	return getOutputStatus(session, channel);
		675	}
		676
		677	/**
		678	* @brief Returns the channel outputStatus register.
		679	* @since 1.1
		680	* @param session The handle returned by snmpOpen()
		681	* @param channel The requested channel in the range of 0...999
		682	* @return The channels outputStatus register
		683	*/
		684	int getOutputStatus(HSNMP session, int channel)
		685	{
		686	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		687	return 0;
		688
		689	return snmpGetInt(session, &outputStatus[channel]);
		690	}
		691
		692	/**
		693	* @brief Returns the measured output sense voltage for channel in Volt.
		694	* @note This is only valid for WIENER LV modules.
		695	* @param session The handle returned by snmpOpen()
		696	* @param channel The requested channel in the range of 0...999
		697	* @return
		698	*/
		699	double getOutputSenseMeasurement(HSNMP session, int channel)
		700	{
		701	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		702	return 0;
		703
		704	return snmpGetDouble(session, &outputMeasurementSenseVoltage[channel]);
		705	}
		706
		707	/**
		708	* @brief Returns the measured output terminal voltage for channel in Volt.
		709	* @param session The handle returned by snmpOpen()
		710	* @param channel The requested channel in the range of 0...999
		711	* @return The measured output terminal voltage in Volt.
		712	*/
		713	double getOutputTerminalMeasurement(HSNMP session, int channel)
		714	{
		715	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		716	return 0;
		717
		718	return snmpGetDouble(session, &outputMeasurementTerminalVoltage[channel]);
		719	}
		720
		721	/**
		722	* @brief Returns the measured output current for channel in Ampere.
		723	* @param session The handle returned by snmpOpen()
		724	* @param channel The requested channel in the range of 0...999
		725	* @return The measured output measurement current in Ampere.
		726	*/
		727	double getCurrentMeasurement(HSNMP session, int channel)
		728	{
		729	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		730	return 0;
		731
		732	return snmpGetDouble(session, &outputMeasurementCurrent[channel]);
		733	}
		734
		735	/**
		736	* @brief Returns the measured temperature for channel in Degree Celsius.
		737	* @note Only WIENER Low Voltage modules have a channel-wise temperature measurement.
		738	* For iseg HV modules, use getModuleAuxTemperature().
		739	* @param session The handle returned by snmpOpen()
		740	* @param channel The requested channel in the range of 0...999
		741	* @return The measured output temperature in Degree Celsius.
		742	*/
		743	int getTemperatureMeasurement(HSNMP session, int channel)
		744	{
		745	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		746	return 0;
		747
		748	return snmpGetInt(session, &outputMeasurementTemperature[channel]);
		749	}
		750
		751	/**
		752	* @brief Change the state of the channel.
		753	* @note This function is deprecated. Use setOutputSwitch() instead.
		754	* @param session The handle returned by snmpOpen()
		755	* @param channel The channel in the range of 0...999
		756	* @param value One of the following: off (0), on (1),
		757	* resetEmergencyOff (2), setEmergencyOff (3), clearEvents (10).
		758	* @return
		759	*/
		760	int setChannelSwitch(HSNMP session, int channel, int value)
		761	{
		762	return setOutputSwitch(session, channel, value);
		763	}
		764
		765	/**
		766	* @brief Change the state of the channel.
		767	* @since 1.1
		768	* @param session The handle returned by snmpOpen()
		769	* @param channel The channel in the range of 0...999
		770	* @param value One of the following: off (0), on (1),
		771	* resetEmergencyOff (2), setEmergencyOff (3), clearEvents (10).
		772	* @return
		773	*/
		774	int setOutputSwitch(HSNMP session, int channel, int value)
		775	{
		776	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		777	return 0;
		778
		779	return snmpSetInt(session, &outputSwitch[channel], value);
		780	}
		781
		782	/**
		783	* @brief Returns the state of the channel.
		784	* @note This function is deprecated. Use getOutputSwitch() instead.
		785	* @param session The handle returned by snmpOpen()
		786	* @param channel The requested channel in the range of 0...999
		787	* @return One of the following: off (0), on (1),
		788	* resetEmergencyOff (2), setEmergencyOff (3), clearEvents (10).
		789	*/
		790	int getChannelSwitch(HSNMP session, int channel)
		791	{
		792	return getOutputSwitch(session, channel);
		793	}
		794
		795	/**
		796	* @brief Returns the state of the channel.
		797	* @since 1.1
		798	* @param session The handle returned by snmpOpen()
		799	* @param channel The requested channel in the range of 0...999
		800	* @return One of the following: off (0), on (1),
		801	* resetEmergencyOff (2), setEmergencyOff (3), clearEvents (10).
		802	*/
		803	int getOutputSwitch(HSNMP session, int channel)
		804	{
		805	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		806	return 0;
		807
		808	return snmpGetInt(session, &outputSwitch[channel]);
		809	}
		810
		811	/**
		812	* @brief setHighVoltageGroupsSwitch
		813	* @param session The handle returned by snmpOpen()
		814	* @param value
		815	* @return
		816	*/
		817	int setHighVoltageGroupsSwitch(HSNMP session, int value)
		818	{
		819	return snmpSetInt(session, &highVoltageGroupsSwitch, value);
		820	}
		821
		822	/**
		823	* @brief getHighVoltageGroupsSwitch
		824	* @param session The handle returned by snmpOpen()
		825	* @return
		826	*/
		827	int getHighVoltageGroupsSwitch(HSNMP session)
		828	{
		829	return snmpGetInt(session, &highVoltageGroupsSwitch);
		830	}
		831
		832	/**
		833	* @brief setLowVoltageGroupsSwitch
		834	* @param session The handle returned by snmpOpen()
		835	* @param value
		836	* @return
		837	*/
		838	int setLowVoltageGroupsSwitch(HSNMP session, int value)
		839	{
		840	return snmpSetInt(session, &lowVoltageGroupsSwitch, value);
		841	}
		842
		843	/**
		844	* @brief getLowVoltageGroupsSwitch
		845	* @param session The handle returned by snmpOpen()
		846	* @return
		847	*/
		848	int getLowVoltageGroupsSwitch(HSNMP session)
		849	{
		850	return snmpGetInt(session, &lowVoltageGroupsSwitch);
		851	}
		852
		853	/**
		854	* @brief Returns the demanded output voltage for channel.
		855	* @param session The handle returned by snmpOpen()
		856	* @param channel The requested channel in the range of 0...999
		857	* @return The demanded output voltage in Volt.
		858	*/
		859	double getOutputVoltage(HSNMP session, int channel)
		860	{
		861	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		862	return 0;
		863
		864	return snmpGetDouble(session, &outputVoltage[channel]);
		865	}
		866
		867	/**
		868	* @brief Sets the demanded output voltage for channel.
		869	* @param session The handle returned by snmpOpen()
		870	* @param channel The requested channel in the range of 0...999
		871	* @param value the demanded output voltage in Volt.
		872	* @return The demanded output voltage in Volt.
		873	*/
		874	double setOutputVoltage(HSNMP session, int channel, double value)
		875	{
		876	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		877	return 0;
		878
		879	return snmpSetDouble(session, &outputVoltage[channel], value);
		880	}
		881
		882	/**
		883	* @brief Returns the demanded maximum output current for channel.
		884	* @param session The handle returned by snmpOpen()
		885	* @param channel The requested channel in the range of 0...999
		886	* @return The demanded output current in Ampere.
		887	*/
		888	double getOutputCurrent(HSNMP session, int channel)
		889	{
		890	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		891	return 0;
		892
		893	return snmpGetDouble(session, &outputCurrent[channel]);
		894	}
		895
		896	/**
		897	* @brief Sets the demanded maximum output current for channel.
		898	* @param session The handle returned by snmpOpen()
		899	* @param channel The channel in the range of 0...999
		900	* @param value The demanded ouput current in Ampere
		901	* @return The demanded maximum output current in Ampere.
		902	*/
		903	double setOutputCurrent(HSNMP session, int channel, double value)
		904	{
		905	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		906	return 0;
		907
		908	return snmpSetDouble(session, &outputCurrent[channel], value);
		909	}
		910
		911	/**
		912	* @brief Returns the channel voltage rise rate in Volt/second.
		913	*
		914	* @note This function is for WIENER LV only.
		915	* For iseg HV modules, use getModuleRampSpeedVoltage().
		916	* @param session The handle returned by snmpOpen()
		917	* @param channel The requested channel in the range of 0...999
		918	* @return
		919	*/
		920	double getOutputRiseRate(HSNMP session, int channel)
		921	{
		922	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		923	return 0;
		924
		925	return snmpGetDouble(session, &outputVoltageRiseRate[channel]);
		926	}
		927
		928	/**
		929	* @brief Sets the channel voltage rise rate in Volt/second.
		930	*
		931	* @note This function is for WIENER LV only.
		932	* For iseg HV modules, use setModuleRampSpeedVoltage().
		933	* @param session The handle returned by snmpOpen()
		934	* @param channel The requested channel in the range of 0...999
		935	* @param value
		936	* @return
		937	*/
		938	double setOutputRiseRate(HSNMP session, int channel, double value)
		939	{
		940	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		941	return 0;
		942
		943	return snmpSetDouble(session, &outputVoltageRiseRate[channel], value);
		944	}
		945
		946	/**
		947	* @brief Returns the channel voltage fall rate in Volt/second.
		948	*
		949	* @note This function is for WIENER LV only.
		950	* For iseg HV modules, use getModuleRampSpeedVoltage().
		951	* @param session The handle returned by snmpOpen()
		952	* @param channel The requested channel in the range of 0...999
		953	* @return
		954	*/
		955	double getOutputFallRate(HSNMP session, int channel)
		956	{
		957	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		958	return 0;
		959
		960	return snmpGetDouble(session, &outputVoltageFallRate[channel]);
		961	}
		962
		963	/**
		964	* @brief Sets the channel voltage fall rate in Volt/second.
		965	*
		966	* @note This function is for WIENER LV only.
		967	* For iseg HV modules, use setModuleRampSpeedVoltage().
		968	* @param session The handle returned by snmpOpen()
		969	* @param channel The requested channel in the range of 0...999
		970	* @param value
		971	* @return
		972	*/
		973	double setOutputFallRate(HSNMP session, int channel, double value)
		974	{
		975	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		976	return 0;
		977
		978	return snmpSetDouble(session, &outputVoltageFallRate[channel], value);
		979	}
		980
		981	/**
		982	* @brief Returns the channel current rise rate in Ampere/second.
		983	*
		984	* @note This function is for WIENER LV only.
		985	* For iseg HV modules, use getModuleRampSpeedCurrent().
		986	* @param session The handle returned by snmpOpen()
		987	* @param channel The requested channel in the range of 0...999
		988	* @return
		989	*/
		990	double getOutputCurrentRiseRate(HSNMP session, int channel)
		991	{
		992	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		993	return 0;
		994
		995	return snmpGetDouble(session, &outputCurrentRiseRate[channel]);
		996	}
		997
		998	/**
		999	* @brief Sets the channel current rise rate in Ampere/second.
		1000	*
		1001	* @note This function is for WIENER LV only.
		1002	* For iseg HV modules, use setModuleRampSpeedCurrent().
		1003	* @param session The handle returned by snmpOpen()
		1004	* @param channel The requested channel in the range of 0...999
		1005	* @param value
		1006	* @return
		1007	*/
		1008	double setOutputCurrentRiseRate(HSNMP session, int channel, double value)
		1009	{
		1010	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1011	return 0;
		1012
		1013	return snmpSetDouble(session, &outputCurrentRiseRate[channel], value);
		1014	}
		1015
		1016	/**
		1017	* @brief Returns the channel current fall rate in Ampere/second.
		1018	*
		1019	* @note This function is for WIENER LV only.
		1020	* For iseg HV modules, use getModuleRampSpeedCurrent().
		1021	* @param session The handle returned by snmpOpen()
		1022	* @param channel The requested channel in the range of 0...999
		1023	* @return
		1024	*/
		1025	double getOutputCurrentFallRate(HSNMP session, int channel)
		1026	{
		1027	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1028	return 0;
		1029
		1030	return snmpGetDouble(session, &outputCurrentFallRate[channel]);
		1031	}
		1032
		1033	/**
		1034	* @brief Sets the channel current fall rate in Ampere/second.
		1035	*
		1036	* @note This function is for WIENER LV only.
		1037	* For iseg HV modules, use setModuleRampSpeedCurrent().
		1038	* @param session The handle returned by snmpOpen()
		1039	* @param channel The requested channel in the range of 0...999
		1040	* @param value
		1041	* @return
		1042	*/
		1043	double setOutputCurrentFallRate(HSNMP session, int channel, double value)
		1044	{
		1045	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1046	return 0;
		1047
		1048	return snmpSetDouble(session, &outputCurrentFallRate[channel], value);
		1049	}
		1050
		1051	/**
		1052	* @brief Returns a bit field packed into an integer
		1053	* which define the behavior of the output channel or power supply after failures.
		1054	* @param session The handle returned by snmpOpen()
		1055	* @param channel The requested channel in the range of 0...999
		1056	* @return
		1057	*/
		1058	int getOutputSupervisionBehavior(HSNMP session, int channel)
		1059	{
		1060	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1061	return 0;
		1062
		1063	return snmpGetInt(session, &outputSupervisionBehavior[channel]);
		1064	}
		1065
		1066	/**
		1067	* @brief Set the behavior of the output channel or power supply after failures.
		1068	*
		1069	* For each supervision value, a two-bit field exists.
		1070	* The enumeration of this value (..L+..H*2) is:
		1071	* WIENER LV devices
		1072	* 0 ignore the failure
		1073	* 1 switch off this channel
		1074	* 2 switch off all channels with the same group number
		1075	* 3 switch off the complete crate.
		1076	* iseg HV devices
		1077	* 0 ignore the failure
		1078	* 1 switch off this channel by ramp down the voltage
		1079	* 2 switch off this channel by a emergencyOff
		1080	* 3 switch off the whole board of the HV module by emergencyOff.
		1081	* The position of the bit fields in the integer value are:
		1082	* Bit 0, 1: outputFailureMinSenseVoltage
		1083	* Bit 2, 3: outputFailureMaxSenseVoltage
		1084	* Bit 4, 5: outputFailureMaxTerminalVoltage
		1085	* Bit 6, 7: outputFailureMaxCurrent
		1086	* Bit 8, 9: outputFailureMaxTemperature
		1087	* Bit 10, 11: outputFailureMaxPower
		1088	* Bit 12, 13: outputFailureInhibit
		1089	* Bit 14, 15: outputFailureTimeout
		1090	* @param session The handle returned by snmpOpen()
		1091	* @param channel The channel (0...999) for which the behaviour should be set
		1092	* @param value The 16 bit integer with bits set according the preceding table.
		1093	* @return
		1094	*/
		1095	int setOutputSupervisionBehavior(HSNMP session, int channel, int value)
		1096	{
		1097	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1098	return 0;
		1099
		1100	return snmpSetInt(session, &outputSupervisionBehavior[channel], value );
		1101	}
		1102
		1103	/**
		1104	* @brief getOutputSupervisionMinSenseVoltage
		1105	* @param session The handle returned by snmpOpen()
		1106	* @param channel The requested channel in the range of 0...999
		1107	* @return
		1108	*/
		1109	double getOutputSupervisionMinSenseVoltage(HSNMP session, int channel)
		1110	{
		1111	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1112	return 0;
		1113
		1114	return snmpGetDouble(session, &outputSupervisionMinSenseVoltage[channel]);
		1115	}
		1116
		1117	/**
		1118	* @brief setOutputSupervisionMinSenseVoltage
		1119	* @param session The handle returned by snmpOpen()
		1120	* @param channel
		1121	* @param value
		1122	* @return
		1123	*/
		1124	double setOutputSupervisionMinSenseVoltage(HSNMP session, int channel, double value)
		1125	{
		1126	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1127	return 0;
		1128
		1129	return snmpSetDouble(session, &outputSupervisionMinSenseVoltage[channel], value);
		1130	}
		1131
		1132	/**
		1133	* @brief getOutputSupervisionMaxSenseVoltage
		1134	* @param session The handle returned by snmpOpen()
		1135	* @param channel The requested channel in the range of 0...999
		1136	* @return
		1137	*/
		1138	double getOutputSupervisionMaxSenseVoltage(HSNMP session, int channel)
		1139	{
		1140	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1141	return 0;
		1142
		1143	return snmpGetDouble(session, &outputSupervisionMaxSenseVoltage[channel]);
		1144	}
		1145
		1146	/**
		1147	* @brief setOutputSupervisionMaxSenseVoltage
		1148	* @param session The handle returned by snmpOpen()
		1149	* @param channel
		1150	* @param value
		1151	* @return
		1152	*/
		1153	double setOutputSupervisionMaxSenseVoltage(HSNMP session, int channel, double value)
		1154	{
		1155	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1156	return 0;
		1157
		1158	return snmpSetDouble(session, &outputSupervisionMaxSenseVoltage[channel], value);
		1159	}
		1160
		1161	/**
		1162	* @brief If the measured voltage at the power supply output terminals is above this value,
		1163	* the power supply performs the function defined by setOutputSupervisionBehavior().
		1164	* @param session The handle returned by snmpOpen()
		1165	* @param channel The requested channel in the range of 0...999
		1166	* @return The maximum terminal voltage in Volt
		1167	*/
		1168	double getOutputSupervisionMaxTerminalVoltage(HSNMP session, int channel)
		1169	{
		1170	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1171	return 0;
		1172
		1173	return snmpGetDouble(session, &outputSupervisionMaxTerminalVoltage[channel]);
		1174	}
		1175
		1176	/**
		1177	* @brief If the measured voltage at the power supply output terminals is above this value,
		1178	* the power supply performs the function defined by setOutputSupervisionBehavior().
		1179	* @param session The handle returned by snmpOpen()
		1180	* @param channel the channel (0...999) to set the max. terminal voltage
		1181	* @param value The maximum terminal voltage in Volt
		1182	* @return
		1183	*/
		1184	double setOutputSupervisionMaxTerminalVoltage(HSNMP session, int channel, double value)
		1185	{
		1186	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1187	return 0;
		1188
		1189	return snmpSetDouble(session, &outputSupervisionMaxTerminalVoltage[channel], value);
		1190	}
		1191
		1192	/**
		1193	* @brief If the measured current is above this value, the power supply
		1194	* performs the function defined by setOutputSupervisionBehavior().
		1195	* @param session The handle returned by snmpOpen()
		1196	* @param channel The requested channel in the range of 0...999
		1197	* @return The maximum output current in Ampere
		1198	*/
		1199	double getOutputSupervisionMaxCurrent(HSNMP session, int channel)
		1200	{
		1201	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1202	return 0;
		1203
		1204	return snmpGetDouble(session, &outputSupervisionMaxCurrent[channel]);
		1205	}
		1206
		1207	/**
		1208	* @brief If the measured current is above this value, the power supply
		1209	* performs the function defined by setOutputSupervisionBehavior().
		1210	* @param session The handle returned by snmpOpen()
		1211	* @param channel The channel (0...999) to set the max. current
		1212	* @param value The maximum current in Ampere
		1213	* @return
		1214	*/
		1215	double setOutputSupervisionMaxCurrent(HSNMP session, int channel, double value)
		1216	{
		1217	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1218	return 0;
		1219
		1220	return snmpSetDouble(session, &outputSupervisionMaxCurrent[channel], value );
		1221	}
		1222
		1223	/**
		1224	* @brief getOutputSupervisionMaxTemperature
		1225	* @param session The handle returned by snmpOpen()
		1226	* @param channel The requested channel in the range of 0...999
		1227	* @return The maximum temperature in degree Celsius
		1228	*/
		1229	int getOutputSupervisionMaxTemperature(HSNMP session, int channel)
		1230	{
		1231	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1232	return 0;
		1233
		1234	return snmpGetInt(session, &outputSupervisionMaxTemperature[channel]);
		1235	}
		1236
		1237	/**
		1238	* @brief getOutputConfigMaxSenseVoltage
		1239	* @param session The handle returned by snmpOpen()
		1240	* @param channel The requested channel in the range of 0...999
		1241	* @return
		1242	*/
		1243	double getOutputConfigMaxSenseVoltage(HSNMP session, int channel)
		1244	{
		1245	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1246	return 0;
		1247
		1248	return snmpGetDouble(session, &outputConfigMaxSenseVoltage[channel]);
		1249	}
		1250
		1251	/**
		1252	* @brief getOutputConfigMaxTerminalVoltage
		1253	* @param session The handle returned by snmpOpen()
		1254	* @param channel The requested channel in the range of 0...999
		1255	* @return
		1256	*/
		1257	double getOutputConfigMaxTerminalVoltage(HSNMP session, int channel)
		1258	{
		1259	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1260	return 0;
		1261
		1262	return snmpGetDouble(session, &outputConfigMaxTerminalVoltage[channel]);
		1263	}
		1264
		1265	/**
		1266	* @brief getOutputConfigMaxCurrent
		1267	* @param session The handle returned by snmpOpen()
		1268	* @param channel The requested channel in the range of 0...999
		1269	* @return
		1270	*/
		1271	double getOutputConfigMaxCurrent(HSNMP session, int channel)
		1272	{
		1273	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1274	return 0;
		1275
		1276	return snmpGetDouble(session, &outputConfigMaxCurrent[channel]);
		1277	}
		1278
		1279	/**
		1280	* @brief getOutputSupervisionMaxPower
		1281	* @param session The handle returned by snmpOpen()
		1282	* @param channel The requested channel in the range of 0...999
		1283	* @return
		1284	*/
		1285	double getOutputSupervisionMaxPower(HSNMP session, int channel)
		1286	{
		1287	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1288	return 0;
		1289
		1290	return snmpGetDouble(session, &outputSupervisionMaxPower[channel]);
		1291	}
		1292
		1293	/**
		1294	* @brief Returns the time span for the delayed trip function.
		1295	* @param session The handle returned by snmpOpen()
		1296	* @param channel The requested channel in the range of 0...999
		1297	* @return the trip delay time (0...4000 ms)
		1298	*/
		1299	int getOutputTripTimeMaxCurrent(HSNMP session, int channel)
		1300	{
		1301	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1302	return 0;
		1303
		1304	return snmpGetInt(session, &outputTripTimeMaxCurrent[channel]);
		1305	}
		1306
		1307	/**
		1308	* @brief Defines a span for the delayed trip function.
		1309	* @param session The handle returned by snmpOpen()
		1310	* @param channel The channel (0...999) for which to set the delayed trip
		1311	* @param delay The trip delay time (0...4000 ms)
		1312	* @return
		1313	*/
		1314	int setOutputTripTimeMaxCurrent(HSNMP session, int channel, int delay)
		1315	{
		1316	if (channel < 0 \|\| channel >= MaxChannelsPerCrate)
		1317	return 0;
		1318
		1319	return snmpSetInt(session, &outputTripTimeMaxCurrent[channel], delay);
		1320	}
		1321
		1322	// Sensor Information functions
		1323
		1324	int getSensorNumber(HSNMP session)
		1325	{
		1326	return snmpGetInt(session, &sensorNumber);
		1327	}
		1328
		1329	int getSensorTemp(HSNMP session, int sensor)
		1330	{
		1331	if (sensor < 0 \|\| sensor > MaxSensors)
		1332	return 0;
		1333
		1334	return snmpGetInt(session, &sensorTemperature[sensor]);
		1335	}
		1336
		1337	int getSensorWarningTemperature(HSNMP session, int sensor)
		1338	{
		1339	if (sensor < 0 \|\| sensor > MaxSensors)
		1340	return 0;
		1341
		1342	return snmpGetInt(session, &sensorWarningThreshold[sensor]);
		1343	}
		1344
		1345	int setSensorWarningTemperature(HSNMP session, int sensor, int value)
		1346	{
		1347	if (sensor < 0 \|\| sensor > MaxSensors)
		1348	return 0;
		1349
		1350	return snmpSetInt(session, &sensorWarningThreshold[sensor], value);
		1351	}
		1352
		1353	int getSensorFailureTemperature(HSNMP session, int sensor)
		1354	{
		1355	if (sensor < 0 \|\| sensor > MaxSensors)
		1356	return 0;
		1357
		1358	return snmpGetInt(session, &sensorFailureThreshold[sensor]);
		1359	}
		1360
		1361	int setSensorFailureTemperature(HSNMP session, int sensor, int value)
		1362	{
		1363	if (sensor < 0 \|\| sensor > MaxSensors)
		1364	return 0;
		1365
		1366	return snmpSetInt(session, &sensorFailureThreshold[sensor], value);
		1367	}
		1368
		1369	// Power Supply specific Functions.
		1370
		1371	/**
		1372	* @brief Returns the crates operating time in seconds.
		1373	* @param session The handle returned by snmpOpen()
		1374	* @return
		1375	*/
		1376	int getPsOperatingTime(HSNMP session)
		1377	{
		1378	return snmpGetInt(session, &psOperatingTime);
		1379	}
		1380
		1381	double getPsAuxVoltage(HSNMP session, int auxIndex)
		1382	{
		1383	if ( (auxIndex < 0) \|\| (auxIndex >= MaxPsAuxSupplies) )
		1384	return 0.0;
		1385
		1386	return snmpGetDouble(session, &psAuxVoltage[auxIndex]);
		1387	}
		1388
		1389	double getPsAuxCurrent(HSNMP session, int auxIndex)
		1390	{
		1391	if ( (auxIndex < 0) \|\| (auxIndex >= MaxPsAuxSupplies) )
		1392	return 0.0;
		1393
		1394	return snmpGetDouble(session, &psAuxCurrent[auxIndex]);
		1395	}
		1396
		1397	// Fan Tray Functions
		1398
		1399	int getFanOperatingTime(HSNMP session)
		1400	{
		1401	return snmpGetInt(session, &fanOperatingTime);
		1402	}
		1403
		1404	int getFanAirTemperature(HSNMP session)
		1405	{
		1406	return snmpGetInt(session, &fanAirTemperature);
		1407	}
		1408
		1409	int getFanSwitchOffDelay(HSNMP session)
		1410	{
		1411	return snmpGetInt(session, &fanSwitchOffDelay);
		1412	}
		1413
		1414	int setFanSwitchOffDelay(HSNMP session, int value)
		1415	{
		1416	return snmpSetInt(session, &fanSwitchOffDelay, value);
		1417	}
		1418
		1419	/**
		1420	* @brief Returns the MPODs fan rotation speed in revolutions per minute.
		1421	* @param session The handle returned by snmpOpen()
		1422	* @return
		1423	*/
		1424	int getFanNominalSpeed(HSNMP session)
		1425	{
		1426	return snmpGetInt(session, &fanNominalSpeed);
		1427	}
		1428
		1429	/**
		1430	* @brief Sets the MPODs fan rotation speed in revolutions per minute.
		1431	* @param session The handle returned by snmpOpen()
		1432	* @param value 1200..3600. 0 turns off the crates fans.
		1433	* @return
		1434	*/
		1435	int setFanNominalSpeed(HSNMP session, int value)
		1436	{
		1437	return snmpSetInt(session, &fanNominalSpeed, value );
		1438	}
		1439
		1440	int getFanNumberOfFans(HSNMP session)
		1441	{
		1442	return snmpGetInt(session, &fanNumberOfFans);
		1443	}
		1444
		1445	int getFanSpeed(HSNMP session, int fan)
		1446	{
		1447	if (fan < 0 \|\| fan > MaxFans)
		1448	return 0;
		1449
		1450	return snmpGetInt(session, &fanSpeed[fan]);
		1451	}
		1452
		1453	/**
		1454	* @brief Returns a pointer to the module description string.
		1455	*
		1456	* The pointer is valid until the next call of any string function.
		1457	* @param session The handle returned by snmpOpen()
		1458	* @param slot The modules slot position in the crate (0...9)
		1459	* @return A string with the following contents, separated by comma and space:
		1460	* - The module vendor ("iseg" or "WIENER")
		1461	* - The module type name
		1462	* - The channel number
		1463	* - The module serial number (optional)
		1464	* - The module firmware release (optional)
		1465	*
		1466	* Example: "iseg, E24D1, 24, 715070, 5.14"
		1467	*/
		1468	char *getModuleDescription(HSNMP session, int slot)
		1469	{
		1470	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1471	return 0;
		1472
		1473	return snmpGetString(session, &moduleDescription[slot]);
		1474	}
		1475
		1476	/**
		1477	* @brief Returns the measured value of the modules +24 Volt line.
		1478	* @note This function is for iseg HV modules only.
		1479	* @param session The handle returned by snmpOpen()
		1480	* @param slot the modules slot position in the crate (0...9)
		1481	* @return the measured +24 Volt line voltage in Volt.
		1482	*/
		1483	double getModuleSupply24(HSNMP session, int slot)
		1484	{
		1485	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1486	return 0.0;
		1487
		1488	return snmpGetDouble(session, &moduleSupply[0][slot]);
		1489	}
		1490
		1491	/**
		1492	* @brief Returns the measured value of the modules +5 Volt line.
		1493	* @note This function is for iseg HV modules only.
		1494	* @param session The handle returned by snmpOpen()
		1495	* @param slot the modules slot position in the crate (0...9)
		1496	* @return the measured +5 Volt line voltage in Volt.
		1497	*/
		1498	double getModuleSupply5(HSNMP session, int slot)
		1499	{
		1500	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1501	return 0.0;
		1502
		1503	return snmpGetDouble(session, &moduleSupply[1][slot]);
		1504	}
		1505
		1506	/**
		1507	* @brief Returns the measured value of one of the modules temperature sensors.
		1508	*
		1509	* @note This function is for iseg HV modules only.
		1510	* @param session The handle returned by snmpOpen()
		1511	* @param slot The modules slot position in the crate (0...9)
		1512	* @param index The temperature sensor index (0...3)
		1513	* @note Most modules only have one temperature sensor at index 0.
		1514	* @return
		1515	*/
		1516	double getModuleAuxTemperature(HSNMP session, int slot, int index)
		1517	{
		1518	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1519	return 0.0;
		1520
		1521	if (index < 0 \|\| index >= MaxModuleAuxTemperatures)
		1522	return 0.0;
		1523
		1524	return snmpGetDouble(session, &moduleAuxiliaryMeasurementTemperature[index][slot]);
		1525	}
		1526
		1527	/**
		1528	* @brief Returns the modules hardware voltage limit in percent.
		1529	*
		1530	* @note This function is for iseg HV modules only.
		1531	* @param session The handle returned by snmpOpen()
		1532	* @param slot The modules slot position in the crate (0...9)
		1533	* @return The modules hardware voltage limit in percent (2...102)
		1534	*/
		1535	double getModuleHardwareLimitVoltage(HSNMP session, int slot)
		1536	{
		1537	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1538	return 0.0;
		1539
		1540	return snmpGetDouble(session, &moduleHardwareLimitVoltage[slot]);
		1541	}
		1542
		1543	/**
		1544	* @brief Returns the modules hardware current limit in percent.
		1545	*
		1546	* @note This function is for iseg HV modules only.
		1547	* @param session The handle returned by snmpOpen()
		1548	* @param slot The modules slot position in the crate (0...9)
		1549	* @return The modules hardware current limit in percent (2...102)
		1550	*/
		1551	double getModuleHardwareLimitCurrent(HSNMP session, int slot)
		1552	{
		1553	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1554	return 0.0;
		1555
		1556	return snmpGetDouble(session, &moduleHardwareLimitCurrent[slot]);
		1557	}
		1558
		1559	/**
		1560	* @brief Returns the modules voltage ramp speed in percent.
		1561	*
		1562	* @note This function is for iseg HV modules only.
		1563	* iseg modules have one common ramp speed for all channels.
		1564	* @param session The handle returned by snmpOpen()
		1565	* @param slot The modules slot position in the crate (0...9)
		1566	* @return The modules voltage ramp speed in percent
		1567	*/
		1568	double getModuleRampSpeedVoltage(HSNMP session, int slot)
		1569	{
		1570	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1571	return 0.0;
		1572
		1573	return snmpGetDouble(session, &moduleRampSpeedVoltage[slot]);
		1574	}
		1575
		1576	/**
		1577	* @brief Sets the modules voltage ramp speed in percent.
		1578	*
		1579	* @note This function is for iseg HV modules only.
		1580	*
		1581	* iseg modules have one common ramp speed for all channels.
		1582	* @param session The handle returned by snmpOpen()
		1583	* @param slot the modules slot position in the crate (0...9)
		1584	* @param value The new voltage ramp speed in percent
		1585	* @note For most modules, the range is 0.001...20 percent.
		1586	* @return The new voltage ramp speed in percent
		1587	*/
		1588	double setModuleRampSpeedVoltage(HSNMP session, int slot, double value)
		1589	{
		1590	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1591	return 0.0;
		1592
		1593	return snmpSetDouble(session, &moduleRampSpeedVoltage[slot], value);
		1594	}
		1595
		1596	/**
		1597	* @brief Returns the modules current ramp speed in percent.
		1598	*
		1599	* @note This function is for iseg HV modules only.
		1600	*
		1601	* iseg modules have one common ramp speed for all channels.
		1602	* This item is only valid for modules with constant current regulation.
		1603	* @param session The handle returned by snmpOpen()
		1604	* @param slot The modules slot position in the crate (0...9)
		1605	* @return The modules current ramp speed in percent
		1606	*/
		1607	double getModuleRampSpeedCurrent(HSNMP session, int slot)
		1608	{
		1609	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1610	return 0.0;
		1611
		1612	return snmpGetDouble(session, &moduleRampSpeedCurrent[slot]);
		1613	}
		1614
		1615	/**
		1616	* @brief Sets the modules current ramp speed in percent.
		1617	*
		1618	* @note This function is for iseg HV modules only.
		1619	*
		1620	* iseg modules have one common ramp speed for all channels.
		1621	* This item is only valid for modules with constant current regulation.
		1622	* @param session The handle returned by snmpOpen()
		1623	* @param slot The modules slot position in the crate (0...9)
		1624	* @param value The new current ramp speed in percent
		1625	* @return The new current ramp speed in percent
		1626	*/
		1627	double setModuleRampSpeedCurrent(HSNMP session, int slot, double value)
		1628	{
		1629	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1630	return 0.0;
		1631
		1632	return snmpSetDouble(session, &moduleRampSpeedCurrent[slot], value);
		1633	}
		1634
		1635	/**
		1636	* @brief Returns the value of the module status register.
		1637	*
		1638	* @note This function is for iseg HV modules only.
		1639	* @param session The handle returned by snmpOpen()
		1640	* @param slot The modules slot position in the crate (0...9)
		1641	* @return The module status register
		1642	*/
		1643	int getModuleStatus(HSNMP session, int slot)
		1644	{
		1645	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1646	return 0;
		1647
		1648	return snmpGetInt(session, &moduleStatus[slot]);
		1649	}
		1650
		1651	/**
		1652	* @brief Returns the value of the module event status register.
		1653	*
		1654	* @note This function is for iseg HV modules only.
		1655	* @param session The handle returned by snmpOpen()
		1656	* @param slot the modules slot position in the crate (0...9)
		1657	* @return The module event status register
		1658	*/
		1659	int getModuleEventStatus(HSNMP session, int slot)
		1660	{
		1661	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1662	return 0;
		1663
		1664	return snmpGetInt(session, &moduleEventStatus[slot]);
		1665	}
		1666
		1667	/**
		1668	* @brief Clears all modules events in a specific slot.
		1669	*
		1670	* To clear all events in all iseg HV modules, use setHighVoltageGroupsSwitch()
		1671	* with the parameter clearEvents(10).
		1672	* @param session The handle returned by snmpOpen()
		1673	* @param slot The modules slot position in the crate (0...9)
		1674	* @return
		1675	*/
		1676	int setModuleDoClear(HSNMP session, int slot)
		1677	{
		1678	if (slot < 0 \|\| slot >= MaxSlotsPerCrate)
		1679	return 0;
		1680
		1681	return snmpSetInt(session, &moduleDoClear[slot], 1);
		1682	}
		1683
		1684	// The rest of the functions are utility functions that actually do the SNMP calls
		1685
		1686	static void logErrors(HSNMP session, struct snmp_pdu *response,
		1687	const SnmpObject object, int status, const char functionName)
		1688	{
		1689	// FAILURE: print what went wrong!
		1690	if (status == STAT_SUCCESS)
		1691	snmp_log(LOG_ERR, "%s(%s): Error in packet. Reason: %s\n",
		1692	functionName, object->desc, snmp_errstring(response->errstat));
		1693	else
		1694	snmp_sess_perror("snmpget", snmp_sess_session(session));
		1695	}
		1696
		1697	static int getIntegerVariable(struct variable_list *vars)
		1698	{
		1699	if (vars->type == ASN_BIT_STR \|\| vars->type == ASN_OCTET_STR) {
		1700	int value = 0;
		1701	for (size_t i = 0; i < vars->val_len && i < sizeof(int); ++i)
		1702	value \|= (vars->val.bitstring[i] << (i * 8));
		1703	return value;
		1704	} if (vars->type == ASN_OPAQUE_FLOAT)
		1705	return (int)*vars->val.floatVal;
		1706	else if (vars->type == ASN_OPAQUE_DOUBLE)
		1707	return (int)*vars->val.doubleVal;
		1708	else if (vars->type == ASN_INTEGER)
		1709	return *vars->val.integer;
		1710	else if (vars->type == ASN_OCTET_STR)
		1711	return *vars->val.integer;
		1712	else if (vars->type == ASN_IPADDRESS)
		1713	return *vars->val.integer;
		1714
		1715	return 0;
		1716	}
		1717
		1718	static double getDoubleVariable(struct variable_list *vars)
		1719	{
		1720	if (vars->type == ASN_OPAQUE_FLOAT)
		1721	return *vars->val.floatVal;
		1722	else if (vars->type == ASN_OPAQUE_DOUBLE)
		1723	return *vars->val.doubleVal;
		1724	else if (vars->type == ASN_INTEGER)
		1725	return (double)*vars->val.integer;
		1726
		1727	return 0.0;
		1728	}
		1729
		1730	static struct snmp_pdu *prepareSetRequestPdu(void)
		1731	{
		1732	struct snmp_pdu *pdu = snmp_pdu_create(SNMP_MSG_SET);
		1733	pdu->community = (u_char *)strdup(m_writeCommunity);
		1734	pdu->community_len = strlen(m_writeCommunity);
		1735
		1736	return pdu;
		1737	}
		1738
		1739	static struct snmp_pdu *prepareGetRequestPdu()
		1740	{
		1741	struct snmp_pdu *pdu = snmp_pdu_create(SNMP_MSG_GET);
		1742
		1743	return pdu;
		1744	}
		1745
		1746	static int snmpGetInt(HSNMP session, const SnmpObject *object)
		1747	{
		1748	int value = 0;
		1749
		1750	struct snmp_pdu *pdu = prepareGetRequestPdu();
		1751
		1752	snmp_add_null_var(pdu, object->id, object->len); // generate request data
		1753
		1754	struct snmp_pdu *response;
		1755	int status = snmp_sess_synch_response(session, pdu, &response);
		1756
		1757	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1758	value = getIntegerVariable(response->variables);
		1759	} else {
		1760	logErrors(session, response, object, status, "snmpGetInt");
		1761	return 0;
		1762	}
		1763
		1764	snmp_free_pdu(response);
		1765	return value;
		1766	}
		1767
		1768	static int snmpSetInt(HSNMP session, const SnmpObject *object, int value)
		1769	{
		1770	struct snmp_pdu *pdu = prepareSetRequestPdu();
		1771
		1772	if (snmp_oid_compare(object->id, object->len, ipStaticAddress.id, ipStaticAddress.len) == 0)
		1773	snmp_pdu_add_variable(pdu, object->id, object->len, ASN_IPADDRESS, (u_char *)&value, sizeof(value));
		1774	else
		1775	snmp_pdu_add_variable(pdu, object->id, object->len, ASN_INTEGER, (u_char *)&value, sizeof(value));
		1776
		1777	int result = value;
		1778	struct snmp_pdu *response;
		1779	int status = snmp_sess_synch_response(session, pdu, &response);
		1780
		1781	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1782	result = getIntegerVariable(response->variables);
		1783	} else {
		1784	logErrors(session, response, object, status, "snmpSetInt");
		1785	return 0;
		1786	}
		1787
		1788	snmp_free_pdu(response);
		1789	return result;
		1790	}
		1791
		1792	static double snmpGetDouble(HSNMP session, const SnmpObject *object)
		1793	{
		1794	double value = 0.0;
		1795
		1796	struct snmp_pdu *pdu = prepareGetRequestPdu();
		1797
		1798	snmp_add_null_var(pdu, object->id, object->len); // generate request data
		1799
		1800	struct snmp_pdu *response;
		1801	int status = snmp_sess_synch_response(session, pdu, &response);
		1802
		1803	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1804	value = getDoubleVariable(response->variables);
		1805	} else {
		1806	logErrors(session, response, object, status, "snmpGetDouble");
		1807	return 0;
		1808	}
		1809
		1810	snmp_free_pdu(response);
		1811	return value;
		1812	}
		1813
		1814	static double snmpSetDouble(HSNMP session, const SnmpObject *object, double value)
		1815	{
		1816	struct snmp_pdu *pdu = prepareSetRequestPdu();
		1817
		1818	float v = (float)value;
		1819	snmp_pdu_add_variable(pdu, object->id, object->len, ASN_OPAQUE_FLOAT, (u_char *)&v, sizeof(v));
		1820
		1821	double result = v;
		1822
		1823	struct snmp_pdu *response;
		1824	int status = snmp_sess_synch_response(session, pdu, &response);
		1825
		1826	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1827	result = getDoubleVariable(response->variables);
		1828	} else {
		1829	logErrors(session, response, object, status, "snmpSetDouble");
		1830	return 0;
		1831	}
		1832
		1833	snmp_free_pdu(response);
		1834	return result;
		1835	}
		1836
		1837	static char snmpGetString(HSNMP session, const SnmpObject object)
		1838	{
		1839	struct snmp_pdu *pdu = prepareGetRequestPdu();
		1840
		1841	snmp_add_null_var(pdu, object->id, object->len); // generate request data
		1842
		1843	struct snmp_pdu *response;
		1844	int status = snmp_sess_synch_response(session, pdu, &response);
		1845
		1846	memset(snmpStringBuffer, 0, sizeof(snmpStringBuffer));
		1847
		1848	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1849	struct variable_list *vars = response->variables;
		1850	if (vars->type == ASN_OCTET_STR) {
		1851	size_t len = sizeof(snmpStringBuffer) - 1;
		1852	if (len > vars->val_len)
		1853	len = vars->val_len;
		1854
		1855	memcpy(snmpStringBuffer, vars->val.string, len);
		1856	snmpStringBuffer[len] = 0;
		1857	}
		1858	} else {
		1859	logErrors(session, response, object, status, "snmpGetString");
		1860	return 0;
		1861	}
		1862
		1863	snmp_free_pdu(response);
		1864	return snmpStringBuffer;
		1865	}
		1866
		1867	static SnmpIntegerBuffer snmpGetMultipleInteger(HSNMP session, const SnmpObject objects, int size)
		1868	{
		1869	struct snmp_pdu *pdu = prepareGetRequestPdu();
		1870
		1871	if (size > MaxChannelsPerSlot)
		1872	size = MaxChannelsPerSlot;
		1873
		1874	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		1875
		1876	for (int i = 0; i < size; ++i)
		1877	snmp_add_null_var(pdu, objects[i].id, objects[i].len); // generate request data
		1878
		1879	struct snmp_pdu *response;
		1880	int status = snmp_sess_synch_response(session, pdu, &response);
		1881
		1882	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1883	struct variable_list *vars;
		1884	for (vars = response->variables; vars; vars = vars->next_variable)
		1885	snmpIntegerBuffer.value[snmpIntegerBuffer.size++] = getIntegerVariable(vars);
		1886	} else {
		1887	logErrors(session, response, &objects[0], status, "snmpGetMultipleInteger");
		1888	return &snmpIntegerBuffer;
		1889	}
		1890
		1891	snmp_free_pdu(response);
		1892	return &snmpIntegerBuffer;
		1893	}
		1894
		1895	static SnmpIntegerBuffer snmpSetMultipleInteger(HSNMP session, const SnmpObject objects, SnmpIntegerBuffer *values)
		1896	{
		1897	struct snmp_pdu *pdu = prepareSetRequestPdu();
		1898
		1899	int size = values->size;
		1900	if (size > MaxChannelsPerSlot)
		1901	size = MaxChannelsPerSlot;
		1902
		1903	for (int i = 0; i < size; ++i) {
		1904	int v = values->value[i];
		1905	snmp_pdu_add_variable(pdu, objects[i].id, objects[i].len, ASN_INTEGER, (u_char *)&v, sizeof(v));
		1906	}
		1907
		1908	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		1909
		1910	struct snmp_pdu *response;
		1911	int status = snmp_sess_synch_response(session, pdu, &response);
		1912
		1913	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1914	struct variable_list *vars;
		1915	for (vars = response->variables; vars; vars = vars->next_variable)
		1916	snmpIntegerBuffer.value[snmpIntegerBuffer.size++] = getIntegerVariable(vars);
		1917	} else {
		1918	logErrors(session, response, &objects[0], status, "snmpSetMultipleInteger");
		1919	return &snmpIntegerBuffer;
		1920	}
		1921
		1922	snmp_free_pdu(response);
		1923	return &snmpIntegerBuffer;
		1924	}
		1925
		1926	static SnmpDoubleBuffer snmpGetMultipleDouble(HSNMP session, const SnmpObject objects, int size)
		1927	{
		1928	struct snmp_pdu *pdu = prepareGetRequestPdu();
		1929
		1930	if (size > MaxChannelsPerSlot)
		1931	size = MaxChannelsPerSlot;
		1932
		1933	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		1934
		1935	for (int i = 0; i < size; ++i)
		1936	snmp_add_null_var(pdu, objects[i].id, objects[i].len); // generate request data
		1937
		1938	struct snmp_pdu *response;
		1939	int status = snmp_sess_synch_response(session, pdu, &response);
		1940
		1941	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1942	struct variable_list *vars;
		1943	for (vars = response->variables; vars; vars = vars->next_variable)
		1944	snmpDoubleBuffer.value[snmpDoubleBuffer.size++] = getDoubleVariable(vars);
		1945	} else {
		1946	logErrors(session, response, &objects[0], status, "snmpGetMultipleDouble");
		1947	return &snmpDoubleBuffer;
		1948	}
		1949
		1950	snmp_free_pdu(response);
		1951
		1952	return &snmpDoubleBuffer;
		1953	}
		1954
		1955	static SnmpDoubleBuffer snmpSetMultipleDouble(HSNMP session, const SnmpObject objects, SnmpDoubleBuffer *values)
		1956	{
		1957	struct snmp_pdu *pdu = prepareSetRequestPdu();
		1958
		1959	int size = values->size;
		1960	if (size > MaxChannelsPerSlot)
		1961	size = MaxChannelsPerSlot;
		1962
		1963	for (int i = 0; i < size; ++i) {
		1964	float v = (float)values->value[i];
		1965	snmp_pdu_add_variable(pdu, objects[i].id, objects[i].len, ASN_OPAQUE_FLOAT, (u_char *)&v, sizeof(v));
		1966	}
		1967
		1968	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		1969
		1970	struct snmp_pdu *response;
		1971	int status = snmp_sess_synch_response(session, pdu, &response);
		1972
		1973	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		1974	struct variable_list *vars;
		1975	for (vars = response->variables; vars; vars = vars->next_variable)
		1976	snmpDoubleBuffer.value[snmpDoubleBuffer.size++] = getDoubleVariable(vars);
		1977	} else {
		1978	logErrors(session, response, &objects[0], status, "snmpSetMultipleDouble");
		1979	return &snmpDoubleBuffer;
		1980	}
		1981
		1982	snmp_free_pdu(response);
		1983	return &snmpDoubleBuffer;
		1984	}
		1985
		1986	/**
		1987	* @brief Returns an array with the outputStatus for a consecutive range of channels.
		1988	*
		1989	* @note This function is deprecated. Use getMultipleOutputStatuses() instead.
		1990	* @param session The handle returned by snmpOpen()
		1991	* @param start The first channel (in the range of 0 to MaxArraySize).
		1992	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		1993	* @param size The number of requested channels.
		1994	* @return A pointer to SnmpIntegerBuffer with the requested information.
		1995	* @note This pointer is only valid until the next call of getMultiple...
		1996	* or setMultiple... function.
		1997	*/
		1998	SnmpIntegerBuffer *getMultipleChannelStatuses(HSNMP session, int start, int size)
		1999	{
		2000	return getMultipleOutputStatuses(session, start, size);
		2001	}
		2002
		2003	/**
		2004	* @brief Returns an array with the outputStatus for a consecutive range of channels.
		2005	* @since 1.1
		2006	* @param session The handle returned by snmpOpen()
		2007	* @param start The first channel (in the range of 0 to MaxArraySize).
		2008	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2009	* @param size The number of requested channels.
		2010	* @return A pointer to SnmpIntegerBuffer with the requested information.
		2011	* @note This pointer is only valid until the next call of getMultiple...
		2012	* or setMultiple... function.
		2013	*/
		2014	SnmpIntegerBuffer *getMultipleOutputStatuses(HSNMP session, int start, int size)
		2015	{
		2016	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2017	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		2018	return &snmpIntegerBuffer;
		2019	}
		2020
		2021	return snmpGetMultipleInteger(session, &outputStatus[start], size);
		2022	}
		2023
		2024	/**
		2025	* @brief Returns an array with the outputSwitches for a consecutive range of channels.
		2026	* @param session The handle returned by snmpOpen()
		2027	* @param start The first channel (in the range of 0 to MaxArraySize).
		2028	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2029	* @param size The number of requested channels.
		2030	* @return A pointer to SnmpIntegerBuffer with the requested information.
		2031	* @note This pointer is only valid until the next call of getMultiple...
		2032	* or setMultiple... function.
		2033	*/
		2034	SnmpIntegerBuffer *getMultipleOutputSwitches(HSNMP session, int start, int size)
		2035	{
		2036	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2037	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		2038	return &snmpIntegerBuffer;
		2039	}
		2040
		2041	return snmpGetMultipleInteger(session, &outputSwitch[start], size);
		2042	}
		2043
		2044	/**
		2045	* @brief Sets the outputSwitch for a consecutive range of channels.
		2046	* @param session The handle returned by snmpOpen()
		2047	* @param start The first channel (in the range of 0 to MaxArraySize).
		2048	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2049	* @param values A pointer to SnmpIntegerBuffer with the list of outputSwitches.
		2050	* @return
		2051	*/
		2052	SnmpIntegerBuffer setMultipleOutputSwitches(HSNMP session, int start, SnmpIntegerBuffer values)
		2053	{
		2054	if (start < 0 \|\| values->size < 0 \|\| start + values->size > MaxChannelsPerCrate) {
		2055	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		2056	return &snmpIntegerBuffer;
		2057	}
		2058
		2059	return snmpSetMultipleInteger(session, &outputSwitch[start], values);
		2060	}
		2061
		2062	/**
		2063	* @brief Returns the actual outputVoltage for a consecutive range of channels.
		2064	* @param session The handle returned by snmpOpen()
		2065	* @param start The first channel (in the range of 0 to MaxArraySize).
		2066	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2067	* @param size The number of requested channels.
		2068	* @return A pointer to SnmpDoubleBuffer with the requested information.
		2069	* @note This pointer is only valid until the next call of getMultiple...
		2070	* or setMultiple... function.
		2071	*/
		2072	SnmpDoubleBuffer *getMultipleOutputVoltages(HSNMP session, int start, int size)
		2073	{
		2074	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2075	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		2076	return &snmpDoubleBuffer;
		2077	}
		2078
		2079	return snmpGetMultipleDouble(session, &outputVoltage[start], size);
		2080	}
		2081
		2082	/**
		2083	* @brief Sets the demanded outputVoltage for a consecutive range of channels.
		2084	* @param session The handle returned by snmpOpen()
		2085	* @param start The first channel (in the range of 0 to MaxArraySize).
		2086	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2087	* @param values A pointer to SnmpDoubleBuffer with the list of new outputVoltages
		2088	* @return
		2089	*/
		2090	SnmpDoubleBuffer setMultipleOutputVoltages(HSNMP session, int start, SnmpDoubleBuffer values)
		2091	{
		2092	if (start < 0 \|\| values->size < 0 \|\| start + values->size > MaxChannelsPerCrate) {
		2093	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		2094	return &snmpDoubleBuffer;
		2095	}
		2096
		2097	return snmpSetMultipleDouble(session, &outputVoltage[start], values);
		2098	}
		2099
		2100	/**
		2101	* @brief Returns the measured terminal voltages for a consecutive range of channels.
		2102	* @param session The handle returned by snmpOpen()
		2103	* @param start The first channel (in the range of 0 to MaxArraySize).
		2104	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2105	* @param size The number of requested channels.
		2106	* @return A pointer to SnmpDoubleBuffer with the requested information.
		2107	* @note This pointer is only valid until the next call of getMultiple...
		2108	* or setMultiple... function.
		2109	*/
		2110	SnmpDoubleBuffer *getMultipleMeasurementTerminalVoltages(HSNMP session, int start, int size)
		2111	{
		2112	return getMultipleOutputMeasurementTerminalVoltages(session, start, size);
		2113	}
		2114
		2115	/**
		2116	* @brief Returns an array with the measured terminal voltages for a consecutive range of channels.
		2117	* @since 1.1
		2118	* @param session The handle returned by snmpOpen()
		2119	* @param start The first channel (in the range of 0 to MaxArraySize).
		2120	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2121	* @param size The number of requested channels.
		2122	* @return A pointer to SnmpDoubleBuffer with the requested information.
		2123	* @note This pointer is only valid until the next call of getMultiple...
		2124	* or setMultiple... function.
		2125	*/
		2126	SnmpDoubleBuffer *getMultipleOutputMeasurementTerminalVoltages(HSNMP session, int start, int size)
		2127	{
		2128	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2129	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		2130	return &snmpDoubleBuffer;
		2131	}
		2132
		2133	return snmpGetMultipleDouble(session, &outputMeasurementTerminalVoltage[start], size);
		2134	}
		2135
		2136	/**
		2137	* @brief getMultipleOutputConfigMaxTerminalVoltages
		2138	* @param session The handle returned by snmpOpen()
		2139	* @param start The first channel (in the range of 0 to MaxArraySize).
		2140	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2141	* @param size The number of requested channels.
		2142	* @return
		2143	*/
		2144	SnmpDoubleBuffer *getMultipleOutputConfigMaxTerminalVoltages(HSNMP session, int start, int size)
		2145	{
		2146	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2147	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		2148	return &snmpDoubleBuffer;
		2149	}
		2150
		2151	return snmpGetMultipleDouble(session, &outputConfigMaxTerminalVoltage[start], size);
		2152	}
		2153
		2154	/**
		2155	* @brief Returns an array the demanded output currents for a consecutive range of channels.
		2156	* @param session The handle returned by snmpOpen()
		2157	* @param start The first channel (in the range of 0 to MaxArraySize).
		2158	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2159	* @param size The number of requested channels.
		2160	* @return
		2161	*/
		2162	SnmpDoubleBuffer *getMultipleOutputCurrents(HSNMP session, int start, int size)
		2163	{
		2164	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2165	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		2166	return &snmpDoubleBuffer;
		2167	}
		2168
		2169	return snmpGetMultipleDouble(session, &outputCurrent[start], size);
		2170	}
		2171
		2172	/**
		2173	* @brief Sets the demanded output current for a consecutive range of channels.
		2174	* @param session The handle returned by snmpOpen()
		2175	* @param start The first channel (in the range of 0 to MaxArraySize).
		2176	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2177	* @param values A pointer to SnmpDoubleBuffer with a list of new output currents
		2178	* @return
		2179	*/
		2180	SnmpDoubleBuffer setMultipleOutputCurrents(HSNMP session, int start, SnmpDoubleBuffer values)
		2181	{
		2182	if (start < 0 \|\| values->size < 0 \|\| start + values->size > MaxChannelsPerCrate) {
		2183	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		2184	return &snmpDoubleBuffer;
		2185	}
		2186
		2187	return snmpSetMultipleDouble(session, &outputCurrent[start], values);
		2188	}
		2189
		2190	/**
		2191	* @brief Returns an array with the measured currents for a consecutive range of channels.
		2192	*
		2193	* @note This function is deprecated. Use getMultipleOutputMeasurementCurrents() instead.
		2194	* @param session The handle returned by snmpOpen()
		2195	* @param start The first channel (in the range of 0 to MaxArraySize).
		2196	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2197	* @param size The number of requested channels.
		2198	* @return A pointer to SnmpDoubleBuffer with the requested information.
		2199	* @note This pointer is only valid until the next call of getMultiple...
		2200	* or setMultiple... function.
		2201	*/
		2202	SnmpDoubleBuffer *getMultipleMeasurementCurrents(HSNMP session, int start, int size)
		2203	{
		2204	return getMultipleOutputMeasurementCurrents(session, start, size);
		2205	}
		2206
		2207	/**
		2208	* @brief Returns an array with the measured currents for a consecutive range of channels.
		2209	* @since 1.1
		2210	* @param session The handle returned by snmpOpen()
		2211	* @param start The first channel (in the range of 0 to MaxArraySize).
		2212	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2213	* @param size The number of requested channels.
		2214	* @return A pointer to SnmpDoubleBuffer with the requested information.
		2215	* @note This pointer is only valid until the next call of getMultiple...
		2216	* or setMultiple... function.
		2217	*/
		2218	SnmpDoubleBuffer *getMultipleOutputMeasurementCurrents(HSNMP session, int start, int size)
		2219	{
		2220	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2221	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		2222	return &snmpDoubleBuffer;
		2223	}
		2224
		2225	return snmpGetMultipleDouble(session, &outputMeasurementCurrent[start], size);
		2226	}
		2227
		2228	/**
		2229	* @brief Returns an array with the outputConfigMaxCurrent for a consecutive range of channels.
		2230	* @param session The handle returned by snmpOpen()
		2231	* @param start The first channel (in the range of 0 to MaxArraySize).
		2232	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2233	* @param size The number of requested channels.
		2234	* @return
		2235	*/
		2236	SnmpDoubleBuffer *getMultipleOutputConfigMaxCurrents(HSNMP session, int start, int size)
		2237	{
		2238	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2239	memset(&snmpDoubleBuffer, 0, sizeof(snmpDoubleBuffer));
		2240	return &snmpDoubleBuffer;
		2241	}
		2242
		2243	return snmpGetMultipleDouble(session, &outputConfigMaxCurrent[start], size);
		2244	}
		2245
		2246	/**
		2247	* @brief Returns an array with the outputTripTimeMaxCurrent for a consecutive range of channels.
		2248	* @param session The handle returned by snmpOpen()
		2249	* @param start The first channel (in the range of 0 to MaxArraySize).
		2250	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2251	* @param size The number of requested channels.
		2252	* @return
		2253	*/
		2254	SnmpIntegerBuffer *getMultipleOutputTripTimeMaxCurrents(HSNMP session, int start, int size)
		2255	{
		2256	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2257	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		2258	return &snmpIntegerBuffer;
		2259	}
		2260
		2261	return snmpGetMultipleInteger(session, &outputTripTimeMaxCurrent[start], size);
		2262	}
		2263
		2264	/**
		2265	* @brief Sets the outputTripTimeMaxCurrent for a consecutive ranges of channels.
		2266	* @param session The handle returned by snmpOpen()
		2267	* @param start The first channel (in the range of 0 to MaxArraySize).
		2268	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2269	* @param values
		2270	* @return
		2271	*/
		2272	SnmpIntegerBuffer setMultipleOutputTripTimeMaxCurrents(HSNMP session, int start, SnmpIntegerBuffer values)
		2273	{
		2274	if (start < 0 \|\| values->size < 0 \|\| start + values->size > MaxChannelsPerCrate) {
		2275	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		2276	return &snmpIntegerBuffer;
		2277	}
		2278
		2279	return snmpSetMultipleInteger(session, &outputTripTimeMaxCurrent[start], values);
		2280	}
		2281
		2282	/**
		2283	* @brief Returns an array with the outputSupervisionBehavior for a consecutive range of channels.
		2284	* @param session The handle returned by snmpOpen()
		2285	* @param start The first channel (in the range of 0 to MaxArraySize).
		2286	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2287	* @param size The number of requested channels.
		2288	* @return
		2289	*/
		2290	SnmpIntegerBuffer *getMultipleOutputSupervisionBehaviors(HSNMP session, int start, int size)
		2291	{
		2292	if (start < 0 \|\| size < 0 \|\| start + size > MaxChannelsPerCrate) {
		2293	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		2294	return &snmpIntegerBuffer;
		2295	}
		2296
		2297	return snmpGetMultipleInteger(session, &outputSupervisionBehavior[start], size);
		2298	}
		2299
		2300	/**
		2301	* @brief Sets the outputSupervisionBehavior for a consecutive range of channels.
		2302	* @param session The handle returned by snmpOpen()
		2303	* @param start The first channel (in the range of 0 to MaxArraySize).
		2304	* 0 = slot 0, channel 0; 100 = slot 1, channel 0.
		2305	* @param values The new outputSupervisionBehavior for the all channels starting with start.
		2306	* @return
		2307	*/
		2308	SnmpIntegerBuffer setMultipleOutputSupervisionBehaviors(HSNMP session, int start, SnmpIntegerBuffer values)
		2309	{
		2310	if (start < 0 \|\| values->size < 0 \|\| start + values->size > MaxChannelsPerCrate) {
		2311	memset(&snmpIntegerBuffer, 0, sizeof(snmpIntegerBuffer));
		2312	return &snmpIntegerBuffer;
		2313	}
		2314
		2315	return snmpSetMultipleInteger(session, &outputSupervisionBehavior[start], values);
		2316	}

Subversion Repositories f9daq

(root)/cvi/instr/MPOD/WIENER_SNMP.c – Rev 153