sensor_tinkerforge.cpp

#ifdef OPTION_TINKERFORGE

#include "sensor_tinkerforge.h"

#include "logger.h"
#include "measurements.h"

sensorTinkerforge::sensorTinkerforge(logger* root, const std::string &sensorID, const std::string &mqttPublishTopic, const std::string &homematicPublishISE, tinkerforge* tinkerManager, const std::string uid, trigger_event triggerEvent, bool isCounter, uint8_t channel, char ioPort, uint32_t debounceTime, double factor, double offset, uint64_t minimumRestPeriod, uint64_t retryTime)
{
	setPointerToLogger(root);
	_isInitialized = false;
	_tinkerMan = tinkerManager;
	_tinkerforgeCallback = NULL;

	setSensorID(sensorID);
	setUID(uid);
	setChannel(channel);
	setIOPort(ioPort);
	setTriggerEvent(triggerEvent);
	setCounter(isCounter);
	setDebounceTime(debounceTime);
	setDeviceType(0);

	setFactor(factor);
	setOffset(offset);
	setMinimumRestPeriod(minimumRestPeriod);
	setRetryTime(retryTime);

	setMQTTPublishTopic(mqttPublishTopic);
	setHomematicPublishISE(homematicPublishISE);
}

sensorTinkerforge::~sensorTinkerforge()
{

}

sensor_type sensorTinkerforge::type() const
{
	return sensor_tinkerforge;
}

std::string sensorTinkerforge::getUID() const
{
	return _uid;
}

unsigned sensorTinkerforge::getDeviceType() const
{
	return _deviceType;
}

uint16_t sensorTinkerforge::getBitMask() const
{
	return _bitMask;
}

uint8_t sensorTinkerforge::getChannel() const
{
	return _channel;
}

char sensorTinkerforge::getIOPort() const
{
	return _ioPort;
}

uint32_t sensorTinkerforge::getDebounceTime() const
{
	return _debounceTime;
}


void sensorTinkerforge::setUID(const std::string &uid)
{
	_uid = uid;
}

void sensorTinkerforge::setDeviceType(unsigned deviceType)
{
	_deviceType = deviceType;
	_isInitialized = true;
}

void sensorTinkerforge::setChannel(uint8_t channel)
{
	_channel = channel;

	uint16_t one = 1;
	_bitMask = (one << _channel);
}

void sensorTinkerforge::setIOPort(char ioPort)
{
	_ioPort = 'a';

	if((ioPort == 'B') || (ioPort == 'b'))
		_ioPort = 'b';
}

void sensorTinkerforge::setDebounceTime(uint32_t debounceTime)
{
	_debounceTime = debounceTime;
}

void sensorTinkerforge::registerCallback()
{
	if(getTriggerEvent() != periodic)
	{
		if(_tinkerforgeCallback != NULL)
			delete _tinkerforgeCallback;

		if(ipcon_get_connection_state(_tinkerMan->_ipcon) == IPCON_CONNECTION_STATE_CONNECTED)
		{
			try
			{
				if(_deviceType == IO4_DEVICE_IDENTIFIER)
					_tinkerforgeCallback = new tinkerforge_callback_io4(this, _tinkerMan);
				else if(_deviceType == IO4_V2_DEVICE_IDENTIFIER)
					_tinkerforgeCallback = new tinkerforge_callback_io4_v2(this, _tinkerMan);
				else if(_deviceType == IO16_DEVICE_IDENTIFIER)
					_tinkerforgeCallback = new tinkerforge_callback_io16(this, _tinkerMan);
				else if(_deviceType == IO16_V2_DEVICE_IDENTIFIER)
					_tinkerforgeCallback = new tinkerforge_callback_io16_v2(this, _tinkerMan);
				else
				{
					std::stringstream ss;
					ss << "Cannot register callback for unknown Bricklet \'" << getUID() << "\' (";
					ss << getDeviceType_name(getDeviceType());
					ss << ").";
					_root->error(ss.str());
					return;
				}

				// Before registering the callback, do a first measurement (poll) of the current state,
				// just in case this is supposed to be broadcast via MQTT.
				// Reset the counters, because we didn't actually count anything.
				try {
					poll(_root->currentTimestamp());
					resetCounters();
				} catch(int e) {
					if(e == E_TIMEOUT)
					{
						// Wait a little bit and try again...
						std::this_thread::sleep_for(std::chrono::milliseconds(5000));
						poll(_root->currentTimestamp());
						resetCounters();
					}
					else throw e;
				}

				try	{
					_tinkerforgeCallback->registerCallback();
				} catch(int e)
				{
					if(e == E_TIMEOUT)
					{
						// Wait a little bit and try again...
						std::this_thread::sleep_for(std::chrono::milliseconds(5000));
						_tinkerforgeCallback->registerCallback();
					}
					else throw e;
				}
			}
			catch(int e)
			{
				std::stringstream ss;
				ss << "Registering callback for Bricklet \'" << getUID() << "\' (";
				ss << getDeviceType_name(getDeviceType());
				ss << "): " << getTFConnectionErrorText(e);
				ss << " failed.";
				_root->error(ss.str());
			}
		}
	}
}

void sensorTinkerforge::failWithReadError(int tf_error_code)
{
	std::stringstream ss;
	ss << "Read Error: Bricklet \'" << getUID() << "\' (" << getDeviceType_name(getDeviceType()) << "). ";
	ss << "Tinkerforge Error Code " << tf_error_code << ": " << getTFConnectionErrorText(tf_error_code) << ".";
	_root->error(ss.str());

	addReadFailure();
}

bool sensorTinkerforge::poll(uint64_t currentTimestamp)
{
	if(_tinkerMan->reconnect())
	{
		if(_isInitialized)
		{
			switch(_deviceType)
			{
				case(AIR_QUALITY_DEVICE_IDENTIFIER):
				{
					AirQuality aq;
					air_quality_create(&aq, _uid.c_str(), _tinkerMan->_ipcon);
					
					int32_t iaq_index, temperature, humidity, air_pressure;
					uint8_t iaq_index_accuracy;

					int result = air_quality_get_all_values(&aq, &iaq_index, &iaq_index_accuracy, &temperature, &humidity, &air_pressure);

					air_quality_destroy(&aq);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue;
						double value = 0;

						switch(getChannel())
						{
							case(1): // Temperature
								ivalue = static_cast<int>(temperature);
								value = static_cast<double>(ivalue)/100.0;
								break;
							case(2): // Humidity
								ivalue = static_cast<int>(humidity);
								value = static_cast<double>(ivalue)/100.0;
								break;
							case(3): // Air pressure
								ivalue = static_cast<int>(air_pressure);
								value = static_cast<double>(ivalue)/100.0;
								break;
							default: // IAQ index
								ivalue = static_cast<int>(iaq_index);
								value = static_cast<double>(ivalue);
								break;
						}  
							
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(CO2_DEVICE_IDENTIFIER):
				{
					CO2 co2;
					co2_create(&co2, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t co2_concentration;
					int result = co2_get_co2_concentration(&co2, &co2_concentration);
					co2_destroy(&co2);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(co2_concentration);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(CO2_V2_DEVICE_IDENTIFIER):
				{
					CO2V2 co2;
					co2_v2_create(&co2, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t co2_concentration, humidity;
					int16_t temperature;

					int result = co2_v2_get_all_values(&co2, &co2_concentration, &temperature, &humidity);

					co2_v2_destroy(&co2);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue;
						double value = 0;

						switch(getChannel())
						{
							case(1): // Temperature
								ivalue = static_cast<int>(temperature);
								value = static_cast<double>(ivalue)/100.0;
								break;
							case(2): // Humidity
								ivalue = static_cast<int>(humidity);
								value = static_cast<double>(ivalue)/100.0;
								break;
							default: // CO2 concentration
								ivalue = static_cast<int>(co2_concentration);
								value = static_cast<double>(ivalue);
								break;
						}

						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(CURRENT12_DEVICE_IDENTIFIER):
				{
					Current12 c;
					current12_create(&c, _uid.c_str(), _tinkerMan->_ipcon);
					
					int16_t current;
					int result = current12_get_current(&c, &current);

					current12_destroy(&c);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(current);
						double value = static_cast<double>(ivalue)/1000.0;
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(CURRENT25_DEVICE_IDENTIFIER):
				{
					Current25 c;
					current25_create(&c, _uid.c_str(), _tinkerMan->_ipcon);
					
					int16_t current;
					int result = current25_get_current(&c, &current);

					current25_destroy(&c);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(current);
						double value = static_cast<double>(ivalue)/1000.0;
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(DISTANCE_IR_DEVICE_IDENTIFIER):
				{
					DistanceIR dir;
					distance_ir_create(&dir, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t distance;
					int result = distance_ir_get_distance(&dir, &distance);

					distance_ir_destroy(&dir);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(distance);
						double value = static_cast<double>(ivalue)/10.0;
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(DISTANCE_IR_V2_DEVICE_IDENTIFIER):
				{
					DistanceIRV2 dir;
					distance_ir_v2_create(&dir, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t distance;
					int result = distance_ir_v2_get_distance(&dir, &distance);

					distance_ir_v2_destroy(&dir);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(distance);
						double value = static_cast<double>(ivalue)/10.0;
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(DISTANCE_US_DEVICE_IDENTIFIER):
				{
					DistanceUS dus;
					distance_us_create(&dus, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t distance;
					int result = distance_us_get_distance_value(&dus, &distance);

					distance_us_destroy(&dus);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(distance);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(DISTANCE_US_V2_DEVICE_IDENTIFIER):
				{
					DistanceUSV2 dus;
					distance_us_v2_create(&dus, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t distance;
					int result = distance_us_v2_get_distance(&dus, &distance);

					distance_us_v2_destroy(&dus);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(distance);
						double value = static_cast<double>(ivalue)/10.0;
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(DUST_DETECTOR_DEVICE_IDENTIFIER):
				{
					DustDetector dd;
					dust_detector_create(&dd, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t dust_density;
					int result = dust_detector_get_dust_density(&dd, &dust_density);

					dust_detector_destroy(&dd);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(dust_density);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(ENERGY_MONITOR_DEVICE_IDENTIFIER):
				{
					EnergyMonitor em;
					energy_monitor_create(&em, _uid.c_str(), _tinkerMan->_ipcon);
					
					int32_t voltage, current, energy, real_power, apparent_power, reactive_power;
    				uint16_t power_factor, frequency;
					int result = energy_monitor_get_energy_data(&em, &voltage, &current, &energy, &real_power, &apparent_power, &reactive_power, &power_factor, &frequency);

					energy_monitor_destroy(&em);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue;
						double value = 0;

						switch(getChannel())
						{
							case(1): // Current
								ivalue = static_cast<int>(current);
								value = static_cast<double>(ivalue) / 100.0;
								break;
							case(2): // Energy
								ivalue = static_cast<int>(energy);
								value = static_cast<double>(ivalue) / 100.0;
								break;
							case(3): // Real Power
								ivalue = static_cast<int>(real_power);
								value = static_cast<double>(ivalue) / 100.0;
								break;
							case(4): // Apparent Power
								ivalue = static_cast<int>(apparent_power);
								value = static_cast<double>(ivalue) / 100.0;
								break;
							case(5): // Reactive Power
								ivalue = static_cast<int>(reactive_power);
								value = static_cast<double>(ivalue) / 100.0;
								break;
							case(6): // Power Factor
								ivalue = static_cast<int>(power_factor);
								value = static_cast<double>(ivalue) / 1000.0;
								break;
							case(7): // Frequency
								ivalue = static_cast<int>(frequency);
								value = static_cast<double>(ivalue) / 100.0;
								break;
							default: // Voltage
								ivalue = static_cast<int>(voltage);
								value = static_cast<double>(ivalue) / 100.0;
								break;
						}

						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(INDUSTRIAL_DUAL_0_20MA_DEVICE_IDENTIFIER):
				{
					IndustrialDual020mA id020;
					industrial_dual_0_20ma_create(&id020, _uid.c_str(), _tinkerMan->_ipcon);
					
					int result;
					int32_t current;
					if(getChannel() == 1)
						result = industrial_dual_0_20ma_get_current(&id020, 1, &current);
					else
						result = industrial_dual_0_20ma_get_current(&id020, 0, &current);

					industrial_dual_0_20ma_destroy(&id020);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(current);
						double value = static_cast<double>(ivalue)/1000000.0;
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(INDUSTRIAL_DUAL_0_20MA_V2_DEVICE_IDENTIFIER):
				{
					IndustrialDual020mAV2 id020;
					industrial_dual_0_20ma_v2_create(&id020, _uid.c_str(), _tinkerMan->_ipcon);
					
					int result;
					int32_t current;
					if(getChannel() == 1)
						result = industrial_dual_0_20ma_v2_get_current(&id020, 1, &current);
					else
						result = industrial_dual_0_20ma_v2_get_current(&id020, 0, &current);

					industrial_dual_0_20ma_v2_destroy(&id020);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(current);
						double value = static_cast<double>(ivalue)/1000000.0;
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(INDUSTRIAL_DUAL_ANALOG_IN_DEVICE_IDENTIFIER):
				{
					IndustrialDualAnalogIn idai;
					industrial_dual_analog_in_create(&idai, _uid.c_str(), _tinkerMan->_ipcon);
					
					int result;
					int32_t voltage;
					if(getChannel() == 1)
						result = industrial_dual_analog_in_get_voltage(&idai, 1, &voltage);
					else
						result = industrial_dual_analog_in_get_voltage(&idai, 0, &voltage);

					industrial_dual_analog_in_destroy(&idai);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(voltage);
						double value = static_cast<double>(ivalue)/1000.0;
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(INDUSTRIAL_DUAL_ANALOG_IN_V2_DEVICE_IDENTIFIER):
				{
					IndustrialDualAnalogInV2 idai;
					industrial_dual_analog_in_v2_create(&idai, _uid.c_str(), _tinkerMan->_ipcon);
					
					int result;
					int32_t voltage;
					if(getChannel() == 1)
						result = industrial_dual_analog_in_v2_get_voltage(&idai, 1, &voltage);
					else
						result = industrial_dual_analog_in_v2_get_voltage(&idai, 0, &voltage);

					industrial_dual_analog_in_v2_destroy(&idai);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(voltage);
						double value = static_cast<double>(ivalue)/1000.0;
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(LASER_RANGE_FINDER_DEVICE_IDENTIFIER):
				{
					LaserRangeFinder lrf;
					laser_range_finder_create(&lrf, _uid.c_str(), _tinkerMan->_ipcon);

					uint16_t distance;

					laser_range_finder_enable_laser(&lrf);
    				std::this_thread::sleep_for(std::chrono::milliseconds(300));

					int result = laser_range_finder_get_distance(&lrf, &distance);
					laser_range_finder_disable_laser(&lrf);

					laser_range_finder_destroy(&lrf);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(distance);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(LASER_RANGE_FINDER_V2_DEVICE_IDENTIFIER):
				{
					LaserRangeFinderV2 lrf;
					laser_range_finder_v2_create(&lrf, _uid.c_str(), _tinkerMan->_ipcon);

					int16_t distance;

					laser_range_finder_v2_set_enable(&lrf, true);
    				std::this_thread::sleep_for(std::chrono::milliseconds(300));

					int result = laser_range_finder_v2_get_distance(&lrf, &distance);
					laser_range_finder_v2_set_enable(&lrf, false);

					laser_range_finder_v2_destroy(&lrf);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(distance);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(LINE_DEVICE_IDENTIFIER):
				{
					Line l;
					line_create(&l, _uid.c_str(), _tinkerMan->_ipcon);

					uint16_t reflectivity;
					int result = line_get_reflectivity(&l, &reflectivity);
					line_destroy(&l);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(reflectivity);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(LOAD_CELL_DEVICE_IDENTIFIER):
				{
					LoadCell lc;
					load_cell_create(&lc, _uid.c_str(), _tinkerMan->_ipcon);

					int32_t weight;
					int result = load_cell_get_weight(&lc, &weight);
					load_cell_destroy(&lc);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(weight);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(LOAD_CELL_V2_DEVICE_IDENTIFIER):
				{
					LoadCellV2 lc;
					load_cell_v2_create(&lc, _uid.c_str(), _tinkerMan->_ipcon);

					int32_t weight;
					int result = load_cell_v2_get_weight(&lc, &weight);
					load_cell_v2_destroy(&lc);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(weight);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(PARTICULATE_MATTER_DEVICE_IDENTIFIER):
				{
					ParticulateMatter pm;
					particulate_matter_create(&pm, _uid.c_str(), _tinkerMan->_ipcon);

					uint16_t pm10, pm25, pm100;
					int result = particulate_matter_get_pm_concentration(&pm, &pm10, &pm25, &pm100);
					particulate_matter_destroy(&pm);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue;
						double value = 0;

						switch(getChannel())
						{
							case(2):
							case(25): // PM25
								ivalue = static_cast<int>(pm25);
								value = static_cast<double>(ivalue);
								break;
							case(3):
							case(100): // PM100
								ivalue = static_cast<int>(pm100);
								value = static_cast<double>(ivalue);
								break;
							default: // PM10
								ivalue = static_cast<int>(pm10);
								value = static_cast<double>(ivalue);
								break;
						}  
							
						addRawMeasurement(value);
					}
					
					return true;
					break;
				}

				case(SOUND_INTENSITY_DEVICE_IDENTIFIER):
				{
					SoundIntensity si;
					sound_intensity_create(&si, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t intensity;
					int result = sound_intensity_get_intensity(&si, &intensity);

					sound_intensity_destroy(&si);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(intensity);
						double value = static_cast<double>(ivalue);
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(SOUND_PRESSURE_LEVEL_DEVICE_IDENTIFIER):
				{
					SoundPressureLevel spl;
					sound_pressure_level_create(&spl, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint16_t decibel;
					int result = sound_pressure_level_get_decibel(&spl, &decibel);

					sound_pressure_level_destroy(&spl);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(decibel);
						double value = static_cast<double>(ivalue)/10.0;
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(TEMPERATURE_IR_DEVICE_IDENTIFIER):
				{
					TemperatureIR tir;
					temperature_ir_create(&tir, _uid.c_str(), _tinkerMan->_ipcon);
					
					int16_t temperature;
					int result;

					if(getChannel() == 1)
						result = temperature_ir_get_object_temperature(&tir, &temperature);
					else
						result = temperature_ir_get_ambient_temperature(&tir, &temperature);

					temperature_ir_destroy(&tir);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(temperature);
						double value = static_cast<double>(ivalue)/10.0;
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(TEMPERATURE_IR_V2_DEVICE_IDENTIFIER):
				{
					TemperatureIRV2 tir;
					temperature_ir_v2_create(&tir, _uid.c_str(), _tinkerMan->_ipcon);
					
					int16_t temperature;
					int result;

					if(getChannel() == 1)
						result = temperature_ir_v2_get_object_temperature(&tir, &temperature);
					else
						result = temperature_ir_v2_get_ambient_temperature(&tir, &temperature);

					temperature_ir_v2_destroy(&tir);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(temperature);
						double value = static_cast<double>(ivalue)/10.0;
						addRawMeasurement(value);
					}

					return true;
					break;
				}

				case(UV_LIGHT_DEVICE_IDENTIFIER):
				{
					UVLight uvl;
					uv_light_create(&uvl, _uid.c_str(), _tinkerMan->_ipcon);
					
					uint32_t uv_light;
					int result = uv_light_get_uv_light(&uvl, &uv_light);

					uv_light_destroy(&uvl);

					if(result < 0)
					{
						failWithReadError(result);
						return false;
					}
					else
					{
						int ivalue = static_cast<int>(uv_light);
						double value = static_cast<double>(ivalue)/10.0;
						addRawMeasurement(value);
					}

					return true;
					break;
				}