#include "stdafx.h"
#include "csocket.h"
#include "csocketevents.h"
#include "utils/utils.h"
#include "math.h"

#include "cphidget.h"
#include "cphidgetdictionary.h"
#include "csocket.h"
#include "clog.h"
#include "cphidgetaccelerometer.h"
#include "cphidgetadvancedservo.h"
#include "cphidgetanalog.h"
#include "cphidgetbridge.h"
#include "cphidgetencoder.h"
#include "cphidgetfrequencycounter.h"
#include "cphidgetgps.h"
#include "cphidgetinterfacekit.h"
#include "cphidgetir.h"
#include "cphidgetmanager.h"
#include "cphidgetled.h"
#include "cphidgetmotorcontrol.h"
#include "cphidgetphsensor.h"
#include "cphidgetrfid.h"
#include "cphidgetservo.h"
#include "cphidgetspatial.h"
#include "cphidgetstepper.h"
#include "cphidgettemperaturesensor.h"
#include "cphidgettextlcd.h"
#include "cphidgettextled.h"
#include "cphidgetweightsensor.h"
#include "cphidgetgeneric.h"

regex_t phidgetsetex;
regex_t managerex;
regex_t managervalex;

PWC_SETKEYS(Accelerometer)
	if(KEYNAME("NumberOfAxes"))
	{
		GET_INT_VAL;
		phid->phid.attr.accelerometer.numAxis = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("Acceleration"))
	{
		if(CHKINDEX(accelerometer.numAxis,ACCEL_MAXAXES))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(axis[index], PUNI_DBL)
			phid->axis[index] = value;
			if(value != PUNK_DBL)
				FIRE(AccelerationChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("AccelerationMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMin, PUNI_DBL)
		phid->accelerationMin = value;
	}
	else if(KEYNAME("AccelerationMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMax, PUNI_DBL)
		phid->accelerationMax = value;
	}
	else if(KEYNAME("Trigger"))
	{
		if(CHKINDEX(accelerometer.numAxis,ACCEL_MAXAXES))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(axisChangeTrigger[index], PUNI_DBL)
			phid->axisChangeTrigger[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else{
		PWC_BAD_SETTYPE(Accelerometer);
	}
	return ret;
}

PWC_SETKEYS(AdvancedServo)
	if(KEYNAME("NumberOfMotors"))
	{
		GET_INT_VAL;
		phid->phid.attr.advancedservo.numMotors = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("Position"))
	{
		if(index < phid->phid.attr.advancedservo.numMotors?phid->phid.attr.advancedservo.numMotors:ADVSERVO_MAXSERVOS)
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorPositionEcho[index], PUNI_DBL)
			phid->motorPositionEcho[index] = value;
			if(value != PUNK_DBL)
				FIRE(PositionChange, index, servo_us_to_degrees(phid->servoParams[index], value, PTRUE));
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("PositionMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(motorPositionMin[index], PUNI_DBL)
		phid->motorPositionMin[index] = value;
	}
	else if(KEYNAME("PositionMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(motorPositionMax[index], PUNI_DBL)
		phid->motorPositionMax[index] = value;
	}
	else if(KEYNAME("PositionMinLimit"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(motorPositionMinLimit, PUNI_DBL)
		phid->motorPositionMinLimit = value;
	}
	else if(KEYNAME("PositionMaxLimit"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(motorPositionMaxLimit, PUNI_DBL)
		phid->motorPositionMaxLimit = value;
	}
	// initial acceleration limit always unknown so don't keyCount++
	else if(KEYNAME("Acceleration"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			GET_DOUBLE_VAL;
			phid->motorAcceleration[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("AccelerationMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMax, PUNI_DBL)
		phid->accelerationMax = value;
	}
	else if(KEYNAME("AccelerationMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMin, PUNI_DBL)
		phid->accelerationMin = value;
	}
	else if(KEYNAME("Current"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorSensedCurrent[index], PUNI_DBL)
			phid->motorSensedCurrent[index] = value;
			if(value != PUNK_DBL)
				FIRE(CurrentChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	// initial velocity limit always unknown so don't keyCount++
	else if(KEYNAME("VelocityLimit"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			GET_DOUBLE_VAL;
			phid->motorVelocity[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("Velocity"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorVelocityEcho[index], PUNI_DBL)
			phid->motorVelocityEcho[index] = value;
			if(value != PUNK_DBL)
				FIRE(VelocityChange, index, servo_us_to_degrees_vel(phid->servoParams[index], value, PTRUE));
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("VelocityMax"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(velocityMax[index], PUNI_DBL)
			phid->velocityMax[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("VelocityMaxLimit"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(velocityMaxLimit, PUNI_DBL)
		phid->velocityMaxLimit = value;
	}
	else if(KEYNAME("VelocityMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(velocityMin, PUNI_DBL)
		phid->velocityMin = value;
	}
	else if(KEYNAME("Engaged"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(motorEngagedStateEcho[index], PUNI_BOOL)
			phid->motorEngagedStateEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("SpeedRampingOn"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(motorSpeedRampingStateEcho[index], PUNI_BOOL)
			phid->motorSpeedRampingStateEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("Stopped"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			GET_INT_VAL;
			unsigned char lastStoppedState = phid->motorStoppedState[index];
			INC_KEYCOUNT(motorStoppedState[index], PUNI_BOOL)
			phid->motorStoppedState[index] = value;
			//If changed, re-run position/velocity events, so the stopped change will be noticed
			if(lastStoppedState != value)
			{
				if(phid->motorVelocityEcho[index] != PUNK_DBL)
					FIRE(VelocityChange, index, servo_us_to_degrees_vel(phid->servoParams[index], phid->motorVelocityEcho[index], PTRUE));
				if(phid->motorPositionEcho[index] != PUNK_DBL)
					FIRE(PositionChange, index, servo_us_to_degrees(phid->servoParams[index], phid->motorPositionEcho[index], PTRUE));
			}
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("ServoParameters"))
	{
		if(CHKINDEX(advancedservo.numMotors, ADVSERVO_MAXSERVOS))
		{
			CPhidgetServoParameters params;
			char *endptr;
			params.servoType = strtol(state, &endptr, 10);
			params.min_us = strtod(endptr+1, &endptr);
			params.max_us = strtod(endptr+1, &endptr);
			params.us_per_degree = strtod(endptr+1, &endptr);
			params.max_us_per_s = strtod(endptr+1, NULL);
			params.state = PTRUE;

			INC_KEYCOUNT(servoParams[index].state, PUNI_BOOL)

			phid->servoParams[index] = params;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else{
		PWC_BAD_SETTYPE(AdvancedServo);
	}
	return ret;
}

PWC_SETKEYS(Analog)
	if(KEYNAME("NumberOfOutputs"))
	{
		GET_INT_VAL;
		phid->phid.attr.analog.numAnalogOutputs = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("Voltage"))
	{
		if(CHKINDEX(analog.numAnalogOutputs, ANALOG_MAXOUTPUTS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(voltageEcho[index], PUNI_DBL)
			phid->voltageEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("VoltageMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(voltageMin, PUNI_DBL)
		phid->voltageMin = value;
	}
	else if(KEYNAME("VoltageMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(voltageMax, PUNI_DBL)
		phid->voltageMax = value;
	}
	else if(KEYNAME("Enabled"))
	{
		if(CHKINDEX(analog.numAnalogOutputs, ANALOG_MAXOUTPUTS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(enabledEcho[index], PUNI_BOOL)
			phid->enabledEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else{
		PWC_BAD_SETTYPE(Analog);
	}
	return ret;
}

PWC_SETKEYS(Bridge)
	if(KEYNAME("NumberOfInputs"))
	{
		GET_INT_VAL;
		phid->phid.attr.bridge.numBridgeInputs = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("DataRate"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(dataRateEcho, PUNI_INT)
		phid->dataRateEcho = value;
	}
	else if(KEYNAME("DataRateMin"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(dataRateMin, PUNI_INT)
		phid->dataRateMin = value;
	}
	else if(KEYNAME("DataRateMax"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(dataRateMax, PUNI_INT)
		phid->dataRateMax = value;
	}
	else if(KEYNAME("Enabled"))
	{
		if(CHKINDEX(bridge.numBridgeInputs, BRIDGE_MAXINPUTS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(enabledEcho[index], PUNI_BOOL)
			phid->enabledEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("BridgeMax"))
	{
		if(CHKINDEX(bridge.numBridgeInputs, BRIDGE_MAXINPUTS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(bridgeMax[index], PUNI_DBL)
			phid->bridgeMax[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("BridgeMin"))
	{
		if(CHKINDEX(bridge.numBridgeInputs, BRIDGE_MAXINPUTS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(bridgeMin[index], PUNI_DBL)
			phid->bridgeMin[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("Gain"))
	{
		if(CHKINDEX(bridge.numBridgeInputs, BRIDGE_MAXINPUTS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(gainEcho[index], PHIDGET_BRIDGE_GAIN_UNKNOWN)
			phid->gainEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("BridgeValue"))
	{
		if(CHKINDEX(bridge.numBridgeInputs, BRIDGE_MAXINPUTS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(bridgeValue[index], PUNI_DBL)
			phid->bridgeValue[index] = value;
			if(value != PUNK_DBL)
				FIRE(BridgeData, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else{
		PWC_BAD_SETTYPE(Bridge);
	}
	return ret;
}

PWC_SETKEYS(Encoder)
	if(KEYNAME("NumberOfEncoders"))
	{
		GET_INT_VAL;
		phid->phid.attr.encoder.numEncoders = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("NumberOfInputs"))
	{
		GET_INT_VAL;
		phid->phid.attr.encoder.numInputs = value;
		phid->phid.keyCount++;
	}
	// initial Input is unknown so don't keyCount++
	else if(KEYNAME("Input"))
	{
		if(CHKINDEX(encoder.numInputs, ENCODER_MAXINPUTS))
		{
			GET_INT_VAL;
			phid->inputState[index] = value;
			if(value != PUNK_BOOL)
				FIRE(InputChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	// initial Position is unknown so don't keyCount++
	else if(KEYNAME("ResetPosition"))
	{
		if(CHKINDEX(encoder.numEncoders, ENCODER_MAXENCODERS))
		{
			GET_INT_VAL;<style>pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span># Channel table for Antonio Carlos - SC - Brazil
# Source: http://portalbsd.com.br/novo/terrestres_channels.php?channels=1468

# Physical channel 21
[Rede Vida]
	DELIVERY_SYSTEM = ISDBT
	BANDWIDTH_HZ = 6000000
	FREQUENCY = 515142857
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	ISDBT_LAYER_ENABLED = 7
	ISDBT_SOUND_BROADCASTING = 0
	ISDBT_SB_SUBCHANNEL_ID = 0
	ISDBT_SB_SEGMENT_IDX = 0
	ISDBT_SB_SEGMENT_COUNT = 0
	ISDBT_LAYERA_FEC = AUTO
	ISDBT_LAYERA_MODULATION = QAM/AUTO
	ISDBT_LAYERA_SEGMENT_COUNT = 0
	ISDBT_LAYERA_TIME_INTERLEAVING = 0
	ISDBT_LAYERB_FEC = AUTO
	ISDBT_LAYERB_MODULATION = QAM/AUTO
	ISDBT_LAYERB_SEGMENT_COUNT = 0
	ISDBT_LAYERB_TIME_INTERLEAVING = 0
	ISDBT_LAYERC_FEC = AUTO
	ISDBT_LAYERC_MODULATION = QAM/AUTO
	ISDBT_LAYERC_SEGMENT_COUNT = 0
	ISDBT_LAYERC_TIME_INTERLEAVING = 0

# Physical channel 30
[RIC SC]
	DELIVERY_SYSTEM = ISDBT
	BANDWIDTH_HZ = 6000000
	FREQUENCY = 569142857
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	ISDBT_LAYER_ENABLED = 7
	ISDBT_SOUND_BROADCASTING = 0
	ISDBT_SB_SUBCHANNEL_ID = 0
	ISDBT_SB_SEGMENT_IDX = 0
	ISDBT_SB_SEGMENT_COUNT = 0
	ISDBT_LAYERA_FEC = AUTO
	ISDBT_LAYERA_MODULATION = QAM/AUTO
	ISDBT_LAYERA_SEGMENT_COUNT = 0
	ISDBT_LAYERA_TIME_INTERLEAVING = 0
	ISDBT_LAYERB_FEC = AUTO
	ISDBT_LAYERB_MODULATION = QAM/AUTO
	ISDBT_LAYERB_SEGMENT_COUNT = 0
	ISDBT_LAYERB_TIME_INTERLEAVING = 0
	ISDBT_LAYERC_FEC = AUTO
	ISDBT_LAYERC_MODULATION = QAM/AUTO
	ISDBT_LAYERC_SEGMENT_COUNT = 0
	ISDBT_LAYERC_TIME_INTERLEAVING = 0

# Physical channel 31
[Record News]
	DELIVERY_SYSTEM = ISDBT
	BANDWIDTH_HZ = 6000000
	FREQUENCY = 575142857
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	ISDBT_LAYER_ENABLED = 7
	ISDBT_SOUND_BROADCASTING = 0
	ISDBT_SB_SUBCHANNEL_ID = 0
	ISDBT_SB_SEGMENT_IDX = 0
	ISDBT_SB_SEGMENT_COUNT = 0
	ISDBT_LAYERA_FEC = AUTO
	ISDBT_LAYERA_MODULATION = QAM/AUTO
	ISDBT_LAYERA_SEGMENT_COUNT = 0
	ISDBT_LAYERA_TIME_INTERLEAVING = 0
	ISDBT_LAYERB_FEC = AUTO
	ISDBT_LAYERB_MODULATION = QAM/AUTO
	ISDBT_LAYERB_SEGMENT_COUNT = 0
	ISDBT_LAYERB_TIME_INTERLEAVING = 0
	ISDBT_LAYERC_FEC = AUTO
	ISDBT_LAYERC_MODULATION = QAM/AUTO
	ISDBT_LAYERC_SEGMENT_COUNT = 0
	ISDBT_LAYERC_TIME_INTERLEAVING = 0

# Physical channel 32
[Band SC]
	DELIVERY_SYSTEM = ISDBT
	BANDWIDTH_HZ = 6000000
	FREQUENCY = 581142857
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	ISDBT_LAYER_ENABLED = 7
	ISDBT_SOUND_BROADCASTING = 0
	ISDBT_SB_SUBCHANNEL_ID = 0
	ISDBT_SB_SEGMENT_IDX = 0
	ISDBT_SB_SEGMENT_COUNT = 0
	ISDBT_LAYERA_FEC = AUTO
	ISDBT_LAYERA_MODULATION = QAM/AUTO
	ISDBT_LAYERA_SEGMENT_COUNT = 0
	ISDBT_LAYERA_TIME_INTERLEAVING = 0
	ISDBT_LAYERB_FEC = AUTO
	ISDBT_LAYERB_MODULATION = QAM/AUTO
	ISDBT_LAYERB_SEGMENT_COUNT = 0
	ISDBT_LAYERB_TIME_INTERLEAVING = 0
	ISDBT_LAYERC_FEC = AUTO
	ISDBT_LAYERC_MODULATION = QAM/AUTO
	ISDBT_LAYERC_SEGMENT_COUNT = 0
	ISDBT_LAYERC_TIME_INTERLEAVING = 0

# Physical channel 33
[RBS SC]
	DELIVERY_SYSTEM = ISDBT
	BANDWIDTH_HZ = 6000000
	FREQUENCY = 587142857
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	ISDBT_LAYER_ENABLED = 7
	ISDBT_SOUND_BROADCASTING = 0
	ISDBT_SB_SUBCHANNEL_ID = 0
	ISDBT_SB_SEGMENT_IDX = 0
	ISDBT_SB_SEGMENT_COUNT = 0
	ISDBT_LAYERA_FEC = AUTO
	ISDBT_LAYERA_MODULATION = QAM/AUTO
	ISDBT_LAYERA_SEGMENT_COUNT = 0
	ISDBT_LAYERA_TIME_INTERLEAVING = 0
	ISDBT_LAYERB_FEC = AUTO
	ISDBT_LAYERB_MODULATION = QAM/AUTO
	ISDBT_LAYERB_SEGMENT_COUNT = 0
	ISDBT_LAYERB_TIME_INTERLEAVING = 0
	ISDBT_LAYERC_FEC = AUTO
	ISDBT_LAYERC_MODULATION = QAM/AUTO
	ISDBT_LAYERC_SEGMENT_COUNT = 0
	ISDBT_LAYERC_TIME_INTERLEAVING = 0

# Physical channel 42
[TV Aparecida]
	DELIVERY_SYSTEM = ISDBT
	BANDWIDTH_HZ = 6000000
	FREQUENCY = 641142857
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	ISDBT_LAYER_ENABLED = 7
	ISDBT_SOUND_BROADCASTING = 0
	ISDBT_SB_SUBCHANNEL_ID = 0
	ISDBT_SB_SEGMENT_IDX = 0
	ISDBT_SB_SEGMENT_COUNT = 0
	ISDBT_LAYERA_FEC = AUTO
	ISDBT_LAYERA_MODULATION = QAM/AUTO
	ISDBT_LAYERA_SEGMENT_COUNT = 0
	ISDBT_LAYERA_TIME_INTERLEAVING = 0
	ISDBT_LAYERB_FEC = AUTO
	ISDBT_LAYERB_MODULATION = QAM/AUTO
	ISDBT_LAYERB_SEGMENT_COUNT = 0
	ISDBT_LAYERB_TIME_INTERLEAVING = 0
	ISDBT_LAYERC_FEC = AUTO
	ISDBT_LAYERC_MODULATION = QAM/AUTO
	ISDBT_LAYERC_SEGMENT_COUNT = 0
	ISDBT_LAYERC_TIME_INTERLEAVING = 0

# Physical channel 61
[TV Câmara, TV Senado, TV AL]
	DELIVERY_SYSTEM = ISDBT
	BANDWIDTH_HZ = 6000000
	FREQUENCY = 755142857
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	ISDBT_LAYER_ENABLED = 7
	ISDBT_SOUND_BROADCASTING = 0
	ISDBT_SB_SUBCHANNEL_ID = 0
	ISDBT_SB_SEGMENT_IDX = 0
	ISDBT_SB_SEGMENT_COUNT = 0
	ISDBT_LAYERA_FEC = AUTO
	ISDBT_LAYERA_MODULATION = QAM/AUTO
	ISDBT_LAYERA_SEGMENT_COUNT = 0
	ISDBT_LAYERA_TIME_INTERLEAVING = 0
	ISDBT_LAYERB_FEC = AUTO
	ISDBT_LAYERB_MODULATION = QAM/AUTO
	ISDBT_LAYERB_SEGMENT_COUNT = 0
	ISDBT_LAYERB_TIME_INTERLEAVING = 0
	ISDBT_LAYERC_FEC = AUTO
	ISDBT_LAYERC_MODULATION = QAM/AUTO
	ISDBT_LAYERC_SEGMENT_COUNT = 0
	ISDBT_LAYERC_TIME_INTERLEAVING = 0

# Physical channel 63
[TV UFSC]
	DELIVERY_SYSTEM = ISDBT
	BANDWIDTH_HZ = 6000000
	FREQUENCY = 767142857
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	INVERSION = AUTO
	GUARD_INTERVAL = AUTO
	TRANSMISSION_MODE = AUTO
	ISDBT_LAYER_ENABLED = 7
	ISDBT_SOUND_BROADCASTING = 0
	ISDBT_SB_SUBCHANNEL_ID = 0
	ISDBT_SB_SEGMENT_IDX = 0
	ISDBT_SB_SEGMENT_COUNT = 0
	ISDBT_LAYERA_FEC = AUTO
	ISDBT_LAYERA_MODULATION = QAM/AUTO
	ISDBT_LAYERA_SEGMENT_COUNT = 0
	ISDBT_LAYERA_TIME_INTERLEAVING = 0
	ISDBT_LAYERB_FEC = AUTO
	ISDBT_LAYERB_MODULATION = QAM/AUTO
	ISDBT_LAYERB_SEGMENT_COUNT = 0
	ISDBT_LAYERB_TIME_INTERLEAVING = 0
	ISDBT_LAYERC_FEC = AUTO
	ISDBT_LAYERC_MODULATION = QAM/AUTO
	ISDBT_LAYERC_SEGMENT_COUNT = 0
	ISDBT_LAYERC_TIME_INTERLEAVING = 0
</pre></div>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.3</a> (<a href='https://git-scm.com/'>git 2.39.1</a>) at 2025-11-27 15:27:51 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>
E(SensorUpdate, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("RawSensor"))
	{
		if(CHKINDEX(motorcontrol.numSensors, MOTORCONTROL_MAXSENSORS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(sensorRawValue[index], PUNI_INT)
			phid->sensorRawValue[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("Ratiometric"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(ratiometricEcho, PUNI_BOOL)
		phid->ratiometricEcho = value;
	}
	else if(KEYNAME("Braking"))
	{
		if(CHKINDEX(motorcontrol.numMotors, MOTORCONTROL_MAXMOTORS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorBrakingEcho[index], PUNI_DBL)
			phid->motorBrakingEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("BackEMF"))
	{
		if(CHKINDEX(motorcontrol.numMotors, MOTORCONTROL_MAXMOTORS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorSensedBackEMF[index], PUNI_DBL)
			phid->motorSensedBackEMF[index] = value;
			if(value != PUNK_DBL)
				FIRE(BackEMFUpdate, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("BackEMFState"))
	{
		if(CHKINDEX(motorcontrol.numMotors, MOTORCONTROL_MAXMOTORS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(backEMFSensingStateEcho[index], PUNI_BOOL)
			phid->backEMFSensingStateEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("SupplyVoltage"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(supplyVoltage, PUNI_DBL)
		phid->supplyVoltage = value;
	}
	else if(KEYNAME("Velocity"))
	{
		if(CHKINDEX(motorcontrol.numMotors, MOTORCONTROL_MAXMOTORS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorSpeedEcho[index], PUNI_DBL)
			phid->motorSpeedEcho[index] = value;
			if(value != PUNK_DBL)
				FIRE(VelocityChange, index, value);
			//Deprecated
			if(value != PUNK_DBL)
				FIRE(MotorChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("Current"))
	{
		if(CHKINDEX(motorcontrol.numMotors, MOTORCONTROL_MAXMOTORS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorSensedCurrent[index], PUNI_DBL)
			phid->motorSensedCurrent[index] = value;
			if(value != PUNK_DBL)
				FIRE(CurrentChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("CurrentUpdate"))
	{
		if(CHKINDEX(motorcontrol.numMotors, MOTORCONTROL_MAXMOTORS))
		{
			GET_DOUBLE_VAL;
			phid->motorSensedCurrent[index] = value;
			if(value != PUNK_DBL)
				FIRE(CurrentUpdate, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	// initial acceleration is unknown so don't keyCount++
	else if(KEYNAME("Acceleration"))
	{
		if(CHKINDEX(motorcontrol.numMotors, MOTORCONTROL_MAXMOTORS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorAccelerationEcho[index], PUNI_DBL)
			phid->motorAccelerationEcho[index] = value;
			phid->motorAcceleration[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("AccelerationMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMin, PUNI_DBL)
		phid->accelerationMin = value;
	}
	else if(KEYNAME("AccelerationMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMax, PUNI_DBL)
		phid->accelerationMax = value;
	}
	// initial Position is unknown so don't keyCount++
	else if(KEYNAME("ResetEncoderPosition"))
	{
		if(CHKINDEX(motorcontrol.numEncoders, MOTORCONTROL_MAXENCODERS))
		{
			GET_INT_VAL;
			phid->encoderPositionDelta[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("EncoderPosition"))
	{
		if(CHKINDEX(motorcontrol.numEncoders, MOTORCONTROL_MAXENCODERS))
		{
			char *endPtr;
			int time = strtol(state, &endPtr, 10);
			int posn = strtol(endPtr+1, NULL, 10);
			int posnChange = posn - phid->encoderPositionEcho[index];
			int encoderTimeChange = time - phid->encoderTimeStamp[index];

			//timeout is 20 seconds
			if (encoderTimeChange > 60000)
				encoderTimeChange = PUNK_INT;

			phid->encoderPositionEcho[index] = posn;
			phid->encoderTimeStamp[index] = time;
			
			FIRE(EncoderPositionChange, index, encoderTimeChange, posnChange);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("EncoderPositionUpdate"))
	{
		if(CHKINDEX(motorcontrol.numEncoders, MOTORCONTROL_MAXENCODERS))
		{
			int posn = strtol(state, NULL, 10);
			int posnChange = posn - phid->encoderPositionUpdates[index];

			phid->encoderPositionUpdates[index] = posn;
			
			FIRE(EncoderPositionUpdate, index, posnChange);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else{
		PWC_BAD_SETTYPE(MotorControl);
	}
	return ret;
}

PWC_SETKEYS(PHSensor)
	if(KEYNAME("PH"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(PH, PUNI_DBL)
		phid->PH = value;
		if(value != PUNK_DBL)
			FIRE(PHChange, value);
	}
	else if(KEYNAME("PHMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(phMin, PUNI_DBL)
		phid->phMin = value;
	}
	else if(KEYNAME("PHMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(phMax, PUNI_DBL)
		phid->phMax = value;
	}
	else if(KEYNAME("Trigger"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(PHChangeTrigger, PUNI_DBL)
		phid->PHChangeTrigger = value;
	}
	else if(KEYNAME("Potential"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(Potential, PUNI_DBL)
		phid->Potential = value;
	}
	else if(KEYNAME("PotentialMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(potentialMin, PUNI_DBL)
		phid->potentialMin = value;
	}
	else if(KEYNAME("PotentialMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(potentialMax, PUNI_DBL)
		phid->potentialMax = value;
	}
	else{
		PWC_BAD_SETTYPE(PHSensor);
	}
	return ret;
}

PWC_SETKEYS(RFID)
	if(KEYNAME("NumberOfOutputs"))
	{
		GET_INT_VAL;
		phid->phid.attr.rfid.numOutputs = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("LastTag"))
	{
		unsigned char tagData[5];
		INC_KEYCOUNT(lastTagValid, PUNI_BOOL)
		phid->lastTagValid = PTRUE;
		
		tagData[0] = (hexval(state[0])<<4)|hexval(state[1]);
		tagData[1] = (hexval(state[2])<<4)|hexval(state[3]);
		tagData[2] = (hexval(state[4])<<4)|hexval(state[5]);
		tagData[3] = (hexval(state[6])<<4)|hexval(state[7]);
		tagData[4] = (hexval(state[8])<<4)|hexval(state[9]);
		
		memcpy(phid->lastTag, tagData, 5);
	}
	else if(KEYNAME("Tag"))
	{
		unsigned char tagData[5];
		//always increment on tagPresent==PUNI_BOOL before setting it!
		INC_KEYCOUNT(tagPresent, PUNI_BOOL)
		phid->tagPresent = 1;
		
		tagData[0] = (hexval(state[0])<<4)|hexval(state[1]);
		tagData[1] = (hexval(state[2])<<4)|hexval(state[3]);
		tagData[2] = (hexval(state[4])<<4)|hexval(state[5]);
		tagData[3] = (hexval(state[6])<<4)|hexval(state[7]);
		tagData[4] = (hexval(state[8])<<4)|hexval(state[9]);

		FIRE(Tag, tagData);
		
		memcpy(phid->lastTag, tagData, 5);
	}
	else if(KEYNAME("TagLoss"))
	{
		//always increment on tagPresent==PUNI_BOOL before setting it!
		INC_KEYCOUNT(tagPresent, PUNI_BOOL)
		phid->tagPresent = 0;
		FIRE(TagLost, phid->lastTag);
	}
	else if(KEYNAME("TagState"))
	{			
		GET_INT_VAL;
		//always increment on tagPresent==PUNI_BOOL before setting it!
		INC_KEYCOUNT(tagPresent, PUNI_BOOL)
		phid->tagPresent = value;
	}
	else if(KEYNAME("Output"))
	{
		if(CHKINDEX(rfid.numOutputs, RFID_MAXOUTPUTS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(outputEchoState[index], PUNI_BOOL)
			phid->outputEchoState[index] = value;
			if(value != PUNK_BOOL)
				FIRE(OutputChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("AntennaOn"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(antennaEchoState, PUNI_BOOL)
		phid->antennaEchoState = value;
	}
	else if(KEYNAME("LEDOn"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(ledEchoState, PUNI_BOOL)
		phid->ledEchoState = value;
	}
	else{
		PWC_BAD_SETTYPE(RFID);
	}
	return ret;
}

PWC_SETKEYS(Servo)
	if(KEYNAME("NumberOfMotors"))
	{
		GET_INT_VAL;
		phid->phid.attr.led.numLEDs = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("Position"))
	{
		if(CHKINDEX(servo.numMotors, SERVO_MAXSERVOS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorPositionEcho[index], PUNI_DBL)
			phid->motorPositionEcho[index]= value;
			if(value != PUNK_DBL)
				FIRE(PositionChange, index, servo_us_to_degrees(phid->servoParams[index], value, PTRUE));
			//Deprecated
			if(value != PUNK_DBL)
				FIRE(MotorPositionChange, index, servo_us_to_degrees(phid->servoParams[index], value, PTRUE));
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("Engaged"))
	{
		if(CHKINDEX(servo.numMotors, SERVO_MAXSERVOS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(motorEngagedStateEcho[index], PUNI_BOOL)
			phid->motorEngagedStateEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("PositionMinLimit"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(motorPositionMinLimit, PUNI_DBL)
		phid->motorPositionMinLimit = value;
	}
	else if(KEYNAME("PositionMaxLimit"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(motorPositionMaxLimit, PUNI_DBL)
		phid->motorPositionMaxLimit = value;
	}
	else if(KEYNAME("ServoParameters"))
	{
		if(CHKINDEX(servo.numMotors, SERVO_MAXSERVOS))
		{
			CPhidgetServoParameters params;
			char *endptr;
			params.servoType = strtol(state, &endptr, 10);
			params.min_us = strtod(endptr+1, &endptr);
			params.max_us = strtod(endptr+1, &endptr);
			params.us_per_degree = strtod(endptr+1, NULL);
			params.state = PTRUE;

			INC_KEYCOUNT(servoParams[index].state, PUNI_BOOL)

			phid->servoParams[index] = params;

			//Set the max/min
			//make sure we don't set max higher then the limit
			if(params.max_us > phid->motorPositionMaxLimit)
				phid->motorPositionMax[index] = phid->motorPositionMaxLimit;
			else
				phid->motorPositionMax[index] = params.max_us;

			phid->motorPositionMin[index] = params.min_us;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else{
		PWC_BAD_SETTYPE(Servo);
	}
	return ret;
}

PWC_SETKEYS(Spatial)
	if(KEYNAME("AccelerationAxisCount"))
	{
		GET_INT_VAL;
		phid->phid.attr.spatial.numAccelAxes = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("GyroAxisCount"))
	{
		GET_INT_VAL;
		phid->phid.attr.spatial.numGyroAxes = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("CompassAxisCount"))
	{
		GET_INT_VAL;
		phid->phid.attr.spatial.numCompassAxes = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("DataRate"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(dataRate, PUNI_INT)
		phid->dataRate = value;
	}
	else if(KEYNAME("DataRateMin"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(dataRateMin, PUNI_INT)
		phid->dataRateMin = value;
	}
	else if(KEYNAME("DataRateMax"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(dataRateMax, PUNI_INT)
		phid->dataRateMax = value;
	}
	else if(KEYNAME("InterruptRate"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(interruptRate, PUNI_INT)
		phid->interruptRate = value;
	}
	else if(KEYNAME("AccelerationMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMin, PUNI_DBL)
		phid->accelerationMin = value;
	}
	else if(KEYNAME("AccelerationMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMax, PUNI_DBL)
		phid->accelerationMax = value;
	}
	else if(KEYNAME("AngularRateMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(angularRateMin, PUNI_DBL)
		phid->angularRateMin = value;
	}
	else if(KEYNAME("AngularRateMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(angularRateMax, PUNI_DBL)
		phid->angularRateMax = value;
	}
	else if(KEYNAME("MagneticFieldMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(magneticFieldMin, PUNI_DBL)
		phid->magneticFieldMin = value;
	}
	else if(KEYNAME("MagneticFieldMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(magneticFieldMax, PUNI_DBL)
		phid->magneticFieldMax = value;
	}
	else if(KEYNAME("SpatialData"))
	{
		CPhidgetSpatial_SpatialEventDataHandle eventData[1];
		CPhidgetSpatial_SpatialEventData spatialData;
		int i;
		char *endptr = (char *)state-1;

		INC_KEYCOUNT(spatialDataNetwork, PUNI_BOOL)
		phid->spatialDataNetwork = PTRUE;
		
		for(i=0;i<SPATIAL_MAX_ACCELAXES;i++)
		{
			phid->accelAxis[i] = spatialData.acceleration[i] = strtod(endptr+1, &endptr);
		}
		for(i=0;i<SPATIAL_MAX_GYROAXES;i++)
		{
			phid->gyroAxis[i] = spatialData.angularRate[i] = strtod(endptr+1, &endptr);
		}
		for(i=0;i<SPATIAL_MAX_COMPASSAXES;i++)
		{
			phid->compassAxis[i] = spatialData.magneticField[i] = strtod(endptr+1, &endptr);
		}

		spatialData.timestamp.seconds = strtol(endptr+1, &endptr, 10);
		spatialData.timestamp.microseconds = strtol(endptr+1, NULL, 10);
		
		eventData[0] = &spatialData;
		FIRE(SpatialData, eventData, 1);
	}
	else{
		PWC_BAD_SETTYPE(Spatial);
	}
	return ret;
}

PWC_SETKEYS(Stepper)
	if(KEYNAME("NumberOfMotors"))
	{
		GET_INT_VAL;
		phid->phid.attr.stepper.numMotors = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("NumberOfInputs"))
	{
		GET_INT_VAL;
		phid->phid.attr.stepper.numInputs = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("Input"))
	{
		if(CHKINDEX(stepper.numInputs, STEPPER_MAXINPUTS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(inputState[index], PUNI_BOOL)
			phid->inputState[index] = value;
			if(value != PUNK_BOOL)
				FIRE(InputChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("CurrentPosition"))
	{
		if(CHKINDEX(stepper.numMotors, STEPPER_MAXSTEPPERS))
		{
			GET_INT64_VAL;
			INC_KEYCOUNT(motorPositionEcho[index], PUNI_INT64)
			phid->motorPositionEcho[index] = value;
			if(value != PUNK_INT64)
				FIRE(PositionChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	// initial target position isn't a keyCount++ sort of thing
	else if(KEYNAME("TargetPosition"))
	{
		if(CHKINDEX(stepper.numMotors, STEPPER_MAXSTEPPERS))
		{
			GET_INT64_VAL;
			INC_KEYCOUNT(motorPosition[index], PUNI_INT64)
			phid->motorPosition[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("PositionMin"))
	{
		GET_INT64_VAL;
		INC_KEYCOUNT(motorPositionMin, PUNI_INT64)
		phid->motorPositionMin = value;
	}
	else if(KEYNAME("PositionMax"))
	{
		GET_INT64_VAL;
		INC_KEYCOUNT(motorPositionMax, PUNI_INT64)
		phid->motorPositionMax = value;
	}
	// initial acceleration is unknown so dont' keyCount++
	else if(KEYNAME("Acceleration"))
	{
		if(CHKINDEX(stepper.numMotors, STEPPER_MAXSTEPPERS))
		{
			GET_DOUBLE_VAL;
			phid->motorAcceleration[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("AccelerationMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMin, PUNI_DBL)
		phid->accelerationMin = value;
	}
	else if(KEYNAME("AccelerationMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(accelerationMax, PUNI_DBL)
		phid->accelerationMax = value;
	}
	// initial current limit is unknown so dont' keyCount++
	else if(KEYNAME("CurrentLimit"))
	{
		if(CHKINDEX(stepper.numMotors, STEPPER_MAXSTEPPERS))
		{
			GET_DOUBLE_VAL;
			phid->motorCurrentLimit[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("Current"))
	{
		if(CHKINDEX(stepper.numMotors, STEPPER_MAXSTEPPERS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorSensedCurrent[index], PUNI_DBL)
			phid->motorSensedCurrent[index] = value;
			if(value != PUNK_DBL)
				FIRE(CurrentChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("CurrentMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(currentMin, PUNI_DBL)
		phid->currentMin = value;
	}
	else if(KEYNAME("CurrentMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(currentMax, PUNI_DBL)
		phid->currentMax = value;
	}
	// initial velocity limit is unknown so dont' keyCount++
	else if(KEYNAME("VelocityLimit"))
	{
		GET_DOUBLE_VAL;
		phid->motorSpeed[index] = value;
	}
	else if(KEYNAME("Velocity"))
	{
		if(CHKINDEX(stepper.numMotors, STEPPER_MAXSTEPPERS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(motorSpeedEcho[index], PUNI_DBL)
			phid->motorSpeedEcho[index] = value;
			if(value != PUNK_DBL)
				FIRE(VelocityChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("VelocityMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(motorSpeedMin, PUNI_DBL)
		phid->motorSpeedMin = value;
	}
	else if(KEYNAME("VelocityMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(motorSpeedMax, PUNI_DBL)
		phid->motorSpeedMax = value;
	}
	else if(KEYNAME("Engaged"))
	{
		if(CHKINDEX(stepper.numMotors, STEPPER_MAXSTEPPERS))
		{
			GET_INT_VAL;
			INC_KEYCOUNT(motorEngagedStateEcho[index], PUNI_BOOL)
			phid->motorEngagedStateEcho[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("Stopped"))
	{
		if(CHKINDEX(stepper.numMotors, STEPPER_MAXSTEPPERS))
		{
			GET_INT_VAL;
			unsigned char lastStoppedState = phid->motorStoppedState[index];
			INC_KEYCOUNT(motorStoppedState[index], PUNI_BOOL)
			phid->motorStoppedState[index] = value;
			//If changed, re-run position/velocity events, so the stopped change will be noticed
			if(lastStoppedState != value)
			{
				if(phid->motorSpeedEcho[index] != PUNK_DBL)
					FIRE(VelocityChange, index, phid->motorSpeedEcho[index]);
				if(phid->motorPositionEcho[index] != PUNK_INT64)
					FIRE(PositionChange, index, phid->motorPositionEcho[index]);
			}
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else{
		PWC_BAD_SETTYPE(Stepper);
	}
	return ret;
}

PWC_SETKEYS(TemperatureSensor)
	if(KEYNAME("NumberOfSensors"))
	{
		GET_INT_VAL;
		phid->phid.attr.temperaturesensor.numTempInputs = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("Potential"))
	{
		if(CHKINDEX(temperaturesensor.numTempInputs, TEMPSENSOR_MAXSENSORS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(Potential[index], PUNI_DBL)
			phid->Potential[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("PotentialMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(potentialMin, PUNI_DBL)
		phid->potentialMin = value;
	}
	else if(KEYNAME("PotentialMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(potentialMax, PUNI_DBL)
		phid->potentialMax = value;
	}
	else if(KEYNAME("Temperature"))
	{
		if(CHKINDEX(temperaturesensor.numTempInputs, TEMPSENSOR_MAXSENSORS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(Temperature[index], PUNI_DBL)
			phid->Temperature[index] = value;
			if(value != PUNK_DBL)
				FIRE(TemperatureChange, index, value);
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else if(KEYNAME("TemperatureMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(temperatureMin[index], PUNI_DBL)
		phid->temperatureMin[index] = value;
	}
	else if(KEYNAME("TemperatureMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(temperatureMax[index], PUNI_DBL)
		phid->temperatureMax[index] = value;
	}
	else if(KEYNAME("AmbientTemperature"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(AmbientTemperature, PUNI_DBL)
		phid->AmbientTemperature = value;
	}
	else if(KEYNAME("AmbientTemperatureMin"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(ambientTemperatureMin, PUNI_DBL)
		phid->ambientTemperatureMin = value;
	}
	else if(KEYNAME("AmbientTemperatureMax"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(ambientTemperatureMax, PUNI_DBL)
		phid->ambientTemperatureMax = value;
	}
	else if(KEYNAME("ThermocoupleType"))
	{
		GET_INT_VAL;
		INC_KEYCOUNT(ThermocoupleType[index], -1)
		phid->ThermocoupleType[index] = value;
	}
	else if(KEYNAME("Trigger"))
	{
		if(CHKINDEX(temperaturesensor.numTempInputs, TEMPSENSOR_MAXSENSORS))
		{
			GET_DOUBLE_VAL;
			INC_KEYCOUNT(TempChangeTrigger[index], PUNI_DBL)
			phid->TempChangeTrigger[index] = value;
		}
		else
			ret = EPHIDGET_OUTOFBOUNDS;
	}
	else{
		PWC_BAD_SETTYPE(TemperatureSensor);
	}
	return ret;
}

PWC_SETKEYS(TextLCD)
	GET_INT_VAL;

	if(KEYNAME("NumberOfRows"))
	{
		INC_KEYCOUNT(rowCount[index], PUNI_INT)
		phid->rowCount[index] = value;
	}
	else if(KEYNAME("NumberOfColumns"))
	{
		INC_KEYCOUNT(columnCount[index], PUNI_INT)
		phid->columnCount[index] = value;
	}
	else if(KEYNAME("NumberOfScreens"))
	{
		phid->phid.attr.textlcd.numScreens = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("Backlight"))
	{
		INC_KEYCOUNT(backlightEcho[index], PUNI_BOOL)
		phid->backlightEcho[index] = (unsigned char)value;
	}
	else if(KEYNAME("CursorOn"))
	{
		phid->cursorOn[index] = (unsigned char)value;
	}
	else if(KEYNAME("CursorBlink"))
	{
		phid->cursorBlink[index] = (unsigned char)value;
	}
	else if(KEYNAME("Contrast"))
	{
		INC_KEYCOUNT(contrastEcho[index], PUNI_INT)
		phid->contrastEcho[index] = (unsigned char)value;
	}
	else if(KEYNAME("Brightness"))
	{
		INC_KEYCOUNT(brightnessEcho[index], PUNI_INT)
		phid->brightnessEcho[index] = (unsigned char)value;
	}
	else if(KEYNAME("ScreenSize"))
	{
		INC_KEYCOUNT(screenSize[index], -1)
		phid->screenSize[index] = value;
	}
	else{
		PWC_BAD_SETTYPE(TextLCD);
	}
	return ret;
}

PWC_SETKEYS(TextLED)
	GET_INT_VAL;
	if(KEYNAME("NumberOfRows"))
	{
		phid->phid.attr.textled.numRows = value;
		phid->phid.keyCount++;
	}
	else if(KEYNAME("NumberOfColumns"))
	{
		phid->phid.attr.textled.numColumns = value;
		phid->phid.keyCount++;
	}
	// this is unknown at attach, so no keyCount++
	else if(KEYNAME("Brightness"))
	{
		phid->brightness = value;
	}
	else{
		PWC_BAD_SETTYPE(TextLED);
	}
	return ret;
}

PWC_SETKEYS(WeightSensor)
	if(KEYNAME("Weight"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(Weight, PUNI_DBL)
		phid->Weight = value;
		if(value != PUNK_DBL)
			FIRE(WeightChange, value);
	}
	else if(KEYNAME("Trigger"))
	{
		GET_DOUBLE_VAL;
		INC_KEYCOUNT(WeightChangeTrigger, PUNI_DBL)
		phid->WeightChangeTrigger = value;
	}
	else{
		PWC_BAD_SETTYPE(WeightSensor);
	}
	return ret;
}

int(*fptrSet[PHIDGET_DEVICE_CLASS_COUNT])(CPhidgetHandle generic_phid, const char *setThing, int index, const char *state, pdict_reason_t reason) = {
NULL,
NULL,
phidgetAccelerometer_set,
phidgetAdvancedServo_set,
phidgetEncoder_set,
phidgetGPS_set,
NULL,//old gyro,
phidgetInterfaceKit_set,
phidgetLED_set,
phidgetMotorControl_set,
phidgetPHSensor_set,
phidgetRFID_set,
phidgetServo_set,
phidgetStepper_set,
phidgetTemperatureSensor_set,
phidgetTextLCD_set,
phidgetTextLED_set,
phidgetWeightSensor_set,
phidgetGeneric_set,
phidgetIR_set,
phidgetSpatial_set,
phidgetFrequencyCounter_set,
phidgetAnalog_set,
phidgetBridge_set};
void network_phidget_event_handler(const char *key, const char *val, unsigned int len, pdict_reason_t reason, void *ptr)
{
	CPhidgetHandle phid = (CPhidgetHandle)ptr;
	regmatch_t pmatch[7];
	char *setThing = NULL;
	char *index = NULL;
	char *serial = NULL;
	char *label = NULL, *l = NULL;
	char errbuf[1024];
	
	int serialNumber;

	int res, ind = PUNK_INT, i, ret = EPHIDGET_OK;

	if(!strncmp(val, "\001", 1) && len == 1)
	{
		memset((char *)val,0,1);
	}


	if(!CPhidget_statusFlagIsSet(phid->status, PHIDGET_SERVER_CONNECTED_FLAG))
	{
		LOG(PHIDGET_LOG_VERBOSE, "network_phidget_event_handler: key ignored: %s Value: %s",key,val);
	}
	else if(reason!=PDR_ENTRY_REMOVING || !strncmp(val, "Detached", sizeof("Detached")))
	{
		LOG(PHIDGET_LOG_VERBOSE, "network_phidget_event_handler: key: %s Value: %s",key,val);
		if ((res = regexec(&phidgetsetex, key, 7, pmatch, 0)) != 0) {
			LOG(PHIDGET_LOG_DEBUG,"Error in network_phidget_event_handler - pattern not met for key: \"%s\"",key);
			return;
		}
		getmatchsub(key, &label, pmatch, 2);
		getmatchsub(key, &serial, pmatch, 3);
		getmatchsub(key, &setThing, pmatch, 4);
		getmatchsub(key, &index, pmatch, 5);
		
		if(l)
		{
			if (!unescape(l, &label, NULL))
			{
				LOG(PHIDGET_LOG_ERROR, "Error in unescape");
				return;
			}
		}

		serialNumber = strtol(serial, NULL, 10);
			
		if(phid->specificDevice == PHIDGETOPEN_ANY && strncmp(val, "Detached", sizeof("Detached")))
		{
			phid->specificDevice = PHIDGETOPEN_ANY_ATTACHED;
			phid->serialNumber = serialNumber;
		}

		if(phid->specificDevice == PHIDGETOPEN_LABEL && strncmp(val, "Detached", sizeof("Detached")))
		{
			phid->serialNumber = serialNumber;
		}
		
		if(serialNumber == phid->serialNumber && setThing)
		{
			if(KEYNAME("Label"))
			{
				strncpy(phid->label, val, MAX_LABEL_STORAGE);
				phid->keyCount++;
			}
			else if(KEYNAME("InitKeys"))
			{
				phid->initKeys = strtol(val, NULL, 10);
				phid->keyCount++;
			}
			else if(KEYNAME("Version"))
			{
				phid->deviceVersion = strtol(val, NULL, 10);
				phid->keyCount++;
			}
			else if(KEYNAME("ID"))
			{
				phid->deviceIDSpec = strtol(val, NULL, 10);
				phid->deviceType = Phid_DeviceName[phid->deviceID];
				phid->keyCount++;

				for(i = 1;i<PHIDGET_DEVICE_COUNT;i++)
				{
					if(Phid_Device_Def[i].pdd_sdid == phid->deviceIDSpec)
					{
						phid->deviceDef = &Phid_Device_Def[i];
						phid->attr = Phid_Device_Def[i].pdd_attr;
						break;
					}
				}
			}
			else if(KEYNAME("Name"))
			{
				phid->keyCount++;
			}
			else if(KEYNAME("Error"))
			{
				char *endptr;
				int errcode = strtol(val, &endptr, 10);
				char *errstr = endptr+1;
				FIRE_ERROR_BUF(errcode, errstr);
			}
			else if(KEYNAME("Status"))
			{
				if(!strncmp(val, "Attached", sizeof("Attached")))
				{
					phid->keyCount++;
				}
				else if(!strncmp(val, "Detached", sizeof("Detached")))
				{
					CThread_mutex_lock(&phid->lock);
					phid->keyCount = 0;
					if(phid->specificDevice == PHIDGETOPEN_ANY_ATTACHED)
					{
						phid->specificDevice = PHIDGETOPEN_ANY;
					}
					CPhidget_clearStatusFlag(&phid->status, PHIDGET_ATTACHED_FLAG, NULL);
					CPhidget_setStatusFlag(&phid->status, PHIDGET_DETACHING_FLAG, NULL);
					CThread_mutex_unlock(&phid->lock);

					if (phid->fptrDetach)
					{
						SET_RUNNING_EVENT(phid)
						phid->fptrDetach((CPhidgetHandle)phid, phid->fptrDetachptr);
						CLEAR_RUNNING_EVENT(phid)
					}

					//clear all variables
					phid->fptrClear((CPhidgetHandle)phid);
					
					//if mDNS & any server, disconnect
#ifdef USE_ZEROCONF
					CThread_mutex_lock(&phid->lock);
					if(phid->networkInfo && !phid->networkInfo->requested_address && !phid->networkInfo->requested_serverID)
					{
						CThread DisconnectPhidgetThread;
						CThread_mutex_unlock(&phid->lock);
						CThread_mutex_lock(&zeroconfPhidgetsLock);
						CList_removeFromList((CListHandle *)&zeroconfPhidgets, phid, CPhidget_areExtraEqual, TRUE, CPhidget_free);
						CThread_mutex_unlock(&zeroconfPhidgetsLock);
						CThread_create_detached(&DisconnectPhidgetThread, DisconnectPhidgetThreadFunction, phid);
					}
					CThread_mutex_unlock(&phid->lock);
#endif
					
					CPhidget_clearStatusFlag(&phid->status, PHIDGET_DETACHING_FLAG, NULL);
						
					phid->deviceIDSpec = 0;
					phid->deviceUID = 0;
					ZEROMEM(&phid->attr, sizeof(CPhidgetAttr));
					if(phid->specificDevice != PHIDGETOPEN_LABEL)
						ZEROMEM(phid->label, MAX_LABEL_STORAGE);
					phid->deviceVersion = 0;
					phid->initKeys = PUNK_INT;

				}
				else
				{
					throw_error_event(phid, "Bad Message type for Status set", EEPHIDGET_NETWORK);
				}
			}
			else if(fptrSet[phid->deviceID] && setThing)
			{
				if(index)
					ind = strtol(index, NULL, 10);

				SET_RUNNING_EVENT(phid)
				ret = fptrSet[phid->deviceID](phid, setThing, ind, val, reason);
				CLEAR_RUNNING_EVENT(phid)
			}
			
			if((phid->initKeys != PUNK_INT) 
				&& (phid->keyCount >= phid->initKeys) 
				&& !CPhidget_statusFlagIsSet(phid->status, PHIDGET_ATTACHED_FLAG)
				&& CPhidget_statusFlagIsSet(phid->status, PHIDGET_OPENED_FLAG))
			{
				LOG(PHIDGET_LOG_VERBOSE, "Got all initkeys, run attach - %d/%d", phid->keyCount, phid->initKeys);

				//Set UID
				phid->deviceUID = CPhidget_getUID(phid->deviceIDSpec, phid->deviceVersion);

				CPhidget_setStatusFlag(&phid->status, PHIDGET_ATTACHED_FLAG, &phid->lock);

				SET_RUNNING_EVENT(phid)
				if (phid->fptrAttach)
					phid->fptrAttach(phid, phid->fptrAttachptr);
				phid->fptrEvents((CPhidgetHandle)phid);
				CLEAR_RUNNING_EVENT(phid)
			}
			else
				LOG(PHIDGET_LOG_VERBOSE, "Accumulating initkeys for attach - %d/%d", phid->keyCount, phid->initKeys == PUNK_INT ? 0 : phid->initKeys);

			//LOG(PHIDGET_LOG_DEBUG, "Message: %s(%s)=%s (%d of %d)", setThing, index, val, phid->keyCount, phid->initKeys);
		}

		free(setThing); setThing = NULL;
		free(index); index = NULL;
		free(serial); serial = NULL;
	}
	
	if(ret)
	{
		snprintf(errbuf, 1024, "Problem during Network set (Phidget): %s\n (Key:\"%s\", Val:\"%s\"", CPhidget_strerror(ret), key, val);
		throw_error_event(phid, errbuf, EEPHIDGET_NETWORK);
	}
}

void network_manager_event_handler(const char *key, const char *val, unsigned int vallen, pdict_reason_t reason, void *ptr)
{
	CPhidgetManagerHandle phidm = (CPhidgetManagerHandle)ptr;
	regmatch_t keymatch[6], valmatch[6];
	char *attachDetach = NULL;
	char *deviceType = NULL;
	char *serial = NULL;
	char *version = NULL;
	char *deviceIDSpec = NULL;
	char *label = NULL;
	char errbuf[1024];
	
	int serialNumber;
	CPhidgetHandle phid;

	//BL:Changed to init Len before use
	int len = 0;

	int res, ret = EPHIDGET_OK;

	int i;
	
	if(!phidm) return;

	if(!strncmp(val, "\001", 1) && (len == 1))
	{
		memset((char *)val,0,1);
	}

	if(reason!=PDR_ENTRY_REMOVING)
	{
		if ((res = regexec(&managerex, key, 3, keymatch, 0)) != 0) {
			LOG(PHIDGET_LOG_DEBUG,"Error in network_manager_event_handler - key pattern not met");
			return;
		}
		if ((res = regexec(&managervalex, val, 5, valmatch, 0)) != 0) {
			LOG(PHIDGET_LOG_DEBUG,"Error in network_manager_event_handler - val pattern not met");
			return;
		}
		getmatchsub(key, &deviceType, keymatch, 1);
		getmatchsub(key, &serial, keymatch, 2);

		getmatchsub(val, &attachDetach, valmatch, 1);
		getmatchsub(val, &version, valmatch, 2);
		getmatchsub(val, &deviceIDSpec, valmatch, 3);
		getmatchsub(val, &label, valmatch, 4);
		
		serialNumber = strtol(serial, NULL, 10);
	
		if((CPhidget_create(&phid))) return;

		phid->deviceID = phidget_type_to_id(deviceType);
		phid->deviceType = Phid_DeviceName[phid->deviceID];
		phid->serialNumber = serialNumber;
		phid->deviceIDSpec = (unsigned short)strtol(deviceIDSpec, NULL, 10);
		phid->deviceVersion = strtol(version, NULL, 10);
		phid->deviceUID = CPhidget_getUID(phid->deviceIDSpec, phid->deviceVersion);
		phid->specificDevice = PHIDGETOPEN_SERIAL; //so it actually compares the serial

		for(i = 1;i<PHIDGET_DEVICE_COUNT;i++)
			if(phid->deviceIDSpec == Phid_Device_Def[i].pdd_sdid) break;
		phid->deviceDef = &Phid_Device_Def[i];
		phid->attr = Phid_Device_Def[i].pdd_attr;

		//so se can get address, etc. from devices.
		phid->networkInfo = phidm->networkInfo;
		CPhidget_setStatusFlag(&phid->status, PHIDGET_REMOTE_FLAG, &phid->lock);
		CPhidget_setStatusFlag(&phid->status, PHIDGET_SERVER_CONNECTED_FLAG, &phid->lock);

		if(label)
		{
			strncpy(phid->label, label, MAX_LABEL_STORAGE);
		}

		if(!strncmp(attachDetach, "Attached", sizeof("Attached")))
		{
			CPhidget_setStatusFlag(&phid->status, PHIDGET_ATTACHED_FLAG, &phid->lock);
		
			CList_addToList((CListHandle *)&phidm->AttachedPhidgets, phid, CPhidget_areEqual);

			if (phidm->fptrAttachChange && phidm->state == PHIDGETMANAGER_ACTIVE)
			{
				SET_RUNNING_EVENT(phidm)
				phidm->fptrAttachChange((CPhidgetHandle)phid, phidm->fptrAttachChangeptr);
				CLEAR_RUNNING_EVENT(phidm)
			}
		}
		
		if(!strncmp(attachDetach, "Detached", sizeof("Detached")))
		{
			CPhidget_clearStatusFlag(&phid->status, PHIDGET_ATTACHED_FLAG, &phid->lock);
			CPhidget_setStatusFlag(&phid->status, PHIDGET_DETACHING_FLAG, &phid->lock);
			if(CList_findInList((CListHandle)phidm->AttachedPhidgets, phid, CPhidget_areEqual, NULL) == EPHIDGET_OK)
			{
				if (phidm->fptrDetachChange && phidm->state == PHIDGETMANAGER_ACTIVE)
				{
					SET_RUNNING_EVENT(phidm)
					phidm->fptrDetachChange((CPhidgetHandle)phid, phidm->fptrDetachChangeptr);
					CLEAR_RUNNING_EVENT(phid)
				}

				CList_removeFromList((CListHandle *)&phidm->AttachedPhidgets, phid, CPhidget_areEqual, PTRUE, CPhidget_free);
			}
			CPhidget_clearStatusFlag(&phid->status, PHIDGET_DETACHING_FLAG, &phid->lock);
			CPhidget_free(phid); phid = NULL;
		}

		free(deviceType); deviceType = NULL;
		free(label); label = NULL;
		free(attachDetach); attachDetach = NULL;
		free(serial); serial = NULL;
		free(version); version = NULL;
		free(deviceIDSpec); deviceIDSpec = NULL;
	}
	
	if(ret)
	{
		snprintf(errbuf, 1024, "Problem during Network set (Manager): %s\n (Key:\"%s\", Val:\"%s\"", CPhidget_strerror(ret), key, val);
		throw_error_event((CPhidgetHandle)phidm, errbuf, EEPHIDGET_NETWORK);
	}
}

void network_heartbeat_event_handler(const char *key, const char *val, unsigned int len, pdict_reason_t reason, void *ptr)
{
	CPhidgetSocketClientHandle server = (CPhidgetSocketClientHandle)ptr;
	double duration = timeSince(&server->lastHeartbeatTime);

	//Keeps a rolling average of the last 5 times
	if(server->avgHeartbeatTimeCount > 5)
	{
		double avg = server->avgHeartbeatTime / server->avgHeartbeatTimeCount;
		server->avgHeartbeatTime -= avg;
		server->avgHeartbeatTimeCount--;
	}
	server->avgHeartbeatTime += duration;
	server->avgHeartbeatTimeCount++;

	server->heartbeatCount++;

	setTimeNow(&server->lastHeartbeatTime);
	server->waitingForHeartbeat = PFALSE;
}