void TempSensorManager::onTempData()
{
string output = QString(tempProcess->readAllStandardOutput()).toStdString();
// No data
if (output.find("Temp =") == string::npos)
{
double now = time(NULL);
double timeSince = now - lastTempUpdateAt;
if (timeSince > resetThreshold)
resetSensor();
return;
}
int index = output.find("Temp =") + 6;
QString qstr(output.substr(index, output.find(" *C") - index).c_str());
double temp = qstr.toDouble();
temp = ((9.0/5.0) * temp) + 32;
// filter bad data
if (Temperature == -1 || abs(int(temp - Temperature)) < 10)
Temperature = temp;
index = output.find("Hum =") + 5;
qstr = QString(output.substr(index, output.find(" %") - index).c_str());
double hum = qstr.toDouble();
if (Humidity == -1 || abs(int(hum - Humidity)) < 10)
Humidity = hum;
lastTempUpdateAt = time(NULL);
emit TempUpdated();
}
uint8_t readTempData_ds18b20(int *temperature) {
if(resetSensor() != 0){
return 1;
}
OWWriteByte(0xCC); //skip rom
OWWriteByte(0x44); //convert T
_delay_ms(800);
if(resetSensor() != 0){
return 1;
}
OWWriteByte(0xCC); //skip rom
OWWriteByte(0xBE); //read scratchpad
*temperature = readScratchpad(2);
//*temperature = 0xFC90;
return 0;
}
/*----------------------------------------------------------------------*
* Change I2C address of the sensor to the provided address (1..127) *
* and do a reset after it in order for the new address to become *
* effective if second parameter is true. *
* Method returns true if the new address is set successfully on sensor.*
*----------------------------------------------------------------------*/
bool I2CSoilMoistureSensor::setAddress(int addr, bool reset) {
writeI2CRegister8bit(sensorAddress, SOILMOISTURESENSOR_SET_ADDRESS, addr);
if (reset) {
resetSensor();
delay(1000);
}
sensorAddress=addr;
return (readI2CRegister8bit(sensorAddress, SOILMOISTURESENSOR_GET_ADDRESS) == addr);
}
/*******************************************************************************
* mvCamSensorReset - request from Camera Sensor to reset itself
*
* DESCRIPTION:
*
* INPUT:
* Pointer to Camera Sensor Data structure.
*
* OUTPUT:
* None
* RETURN:
* MV_BAD_PTR: if Sensor data structure is invalid
* MV_ERROR: I2C failure
* MV_ERROR: if senser reports failure
* MV_OK otherwise
*******************************************************************************/
MV_STATUS mvCamSensorReset(MV_CAM_SENSOR *pCamSensor)
{
mvOsOutput("mvCamSensorReset\n");
if(!pCamSensor)
{
mvOsPrintf("mvCamSensorReset: Bad Input\n");
return MV_BAD_PTR;
}
return resetSensor(pCamSensor);
}
void LM95172::init() {
pinMode(PIN_CS, OUTPUT);
pinMode(PIN_CLK, OUTPUT);
pinMode(PIN_SIO, INPUT);
digitalWrite(PIN_CS, HIGH);
digitalWrite(PIN_CLK, LOW);
digitalWrite(PIN_SIO, HIGH);
currentUnit = FAHRENHEIT;
resetSensor();
}
// begin
void VirtualShield::begin(long baudRate) {
// Set default task inteval
VirtualShield::taskInterval = 1000;
// Begin Serials
Bluetooth.begin(baudRate);
Log.init(baudRate);
// @todo Reset Sensors
resetSensor();
// Unset Task
unsetTask();
// Reset Buffer Position
flushBuffer();
// @debug
Log.w("Ready");
}
/*******************************************************************************
* mvCamSensorInit - Initialize the Camera Sensor
*
* DESCRIPTION:
* this function does the following:
* 1. Initializes the internal fields of the data stucture.
* 2. initialize the sensor and loads default values.
* 3. checks if the senser id match the support device
*
* INPUT:
* Pointer to Camera Sensor Data structure, this sturcture must be allocated
* by callee.
* OUTPUT:
* None
* RETURN:
* MV_BAD_PTR: if data structure not allocated or have bad external field
* MV_FAIL: failed to allocate memory
* MV_NOT_FOUND: if sensor id doesn't match
* MV_ERROR: I2C failure transaction failure or if the senser reports failure
* MV_OK otherwise
*******************************************************************************/
MV_STATUS mvCamSensorInit(MV_CAM_SENSOR *pCamSensor)
{
OV7680_INFO *pInfo;
mvOsOutput("mvCamSensorInit\n");
if(!pCamSensor)
{
mvOsPrintf("mvCamSensorInit: Bad Input\n");
return MV_BAD_PTR;
}
pInfo = mvOsMalloc(sizeof(OV7680_INFO));
pCamSensor->pInfo = pInfo;
if(!pCamSensor->pInfo)
{
mvOsPrintf("mvCamSensorInit: failed to allocate memory\n");
return MV_FAIL;
}
pInfo->pixFormat = supportedFormats;
pInfo->resolution = supportedResolutions;
/* reset */
if (resetSensor(pCamSensor) != MV_OK)
{
mvOsPrintf("mvCamSensorInit: sensor reset failed\n");
return MV_ERROR;
}
/*load defaults*/
if(sensorRegsWrite(pCamSensor, ov7680_default_settings,
sizeof(ov7680_default_settings)/sizeof(sensorReg_t)) != MV_OK){
mvOsPrintf("mvCamSensorInit: sensor default registers loading failed\n");
return MV_ERROR;
}
return isOV7680(pCamSensor);
}
void VirtualShield::listen() {
byte fixedHeader = 0;
byte remainingLength = 0;
if (Bluetooth.available() > 0)
fixedHeader = Bluetooth.read();
if (Bluetooth.available() > 0)
remainingLength = Bluetooth.read();
byte i = 0;
while (Bluetooth.available() > 0 && i < remainingLength) {
buffer[i] = Bluetooth.read();
i++;
}
// Create MQTTMessage
MQTTMessage mqtt(fixedHeader, remainingLength, buffer);
// Parse Messages
switch (mqtt.getType()) {
case CONNECT: {
Log.w("Connected");
// Set Connect Flag
connectFlag = true;
// Send Connect Acknowledgement
sendConnectAck();
// @todo Start sending SUBSCRIBE
for(byte i = 1; i < SHIELD_COUNT; i++) {
if (sensorCallback[i] != 0 && isSubscribe[i] == false) {
// @debug
// Log.w("MQTT", "Send SUBSCRIBE", i);
delay(30);
sendSubscribe(i + SHIELD_OFFSET);
isSubscribe[i] = true;
}
}
break;
}
case PUBLISH: {
// @debug
Log.w("MQTT", "PUBLISH Received");
// Log.w("MQTT", "Buffer", buffer, remainingLength);
// Get Topic
byte *topicPtr;
byte topicLen = mqtt.readTopic(&topicPtr);
// Get Shield
byte shield = *topicPtr - SHIELD_OFFSET;
Log.w("Shield", shield);
// Call Callbacks
if (shield < SHIELD_COUNT &&
sensorCallback[shield] != 0 &&
isSubscribe[shield] == true) {
// Get Payload Pointer
byte *payloadPtr;
byte payloadLength = mqtt.readPayload(&payloadPtr);
// @debug
// Log.w("payload", payloadPtr, payloadLength);
// // Get Callback
void (*receiver)(byte * payload, byte length) = sensorCallback[shield];
// // Run Callback
receiver(payloadPtr, payloadLength);
}
break;
}
case SUBSCRIBE: {
break;
}
case SUBACK: {
// @debug
// Log.w("MQTT", "SUBACK Received");
// Log.w("MQTT", "Buffer", buffer, remainingLength);
// // Get Topic
// byte *topicPtr;
// mqtt.readTopic(&topicPtr);
// byte shield = *topicPtr - SHIELD_OFFSET;
// if (sensorCallback[shield] != 0 && isSubscribe[shield] == false) {
// isSubscribe[shield] = true;
// // @debug
// Log.w("MQTT", "Topic Subscribed", shield);
// }
// break;
}
case UNSUBSCRIBE: {
break;
}
case UNSUBACK: {
break;
}
case DISCONNECT: {
Log.w("Disconnected");
// Set connect flag
connectFlag = false;
// Clear subscription
resetSensor();
break;
}
}
// flushBuffer();
}
/*----------------------------------------------------------------------*
* Initializes anything ... it does a reset. *
* When used without parameter or parameter value is false then a *
* waiting time of at least 1 second is expected to give the sensor *
* some time to boot up. *
* Alternatively use true as parameter and the method waits for a *
* second and returns after that. *
*----------------------------------------------------------------------*/
void I2CSoilMoistureSensor::begin(bool wait) {
resetSensor();
if (wait) {
delay(1000);
}
}
