WaspSensorAgr Class Reference

WaspSensorAgr Class. More...

#include <WaspSensorAgr.h>

Public Member Functions
	WaspSensorAgr ()
	class constructor
void	setBoardMode (uint8_t mode)
	It sets board power mode, setting ON/OFF 3v3 and 5V switches.
void	setSensorMode (uint8_t mode, uint16_t sensor)
	It sets ON/OFF the different sensor switches.
float	readValue (uint16_t sensor)
	It reads the value measured by the sensor.
float	readValue (uint16_t sensor, uint8_t type)
	It reads the value measured by the sensor.
void	setAnemometerThreshold (float threshold)
	It sets threshold configuring digipots.
void	sleepAgr (const char *time2wake, uint8_t offset, uint8_t mode, uint8_t option)
	It sleeps Waspmote enabling the switches required for the agriculture board.
void	sleepAgr (const char *time2wake, uint8_t offset, uint8_t mode, uint8_t option, uint8_t agr_interrupt)
	It sleeps Waspmote enabling the switches required for the agriculture board.
void	attachInt (uint8_t sens)
	It switches off the general switch enabling RTC interruption for the Agriculture Board.
void	detachInt (uint8_t sens)
	It attaches the interruption.
Data Fields
uint16_t	vane_direction
	Variable : specifies the wind direction.
Private Member Functions
void	setDigipot (float value)
	It sets the Digipot threshold.
float	readDendrometer ()
	It reads from the dendrometer.
float	readPT1000 ()
	It reads from the PT1000.
float	readRadiation ()
	It reads from the radiation sensors.
float	readWatermark (uint8_t sens)
	It reads from the Watermark.
float	readSensirion (uint8_t parameter)
	It reads from the sensirion.
uint16_t	readPluviometer ()
	It reads from the pluviometer.
float	conversion (byte data_input[3], uint8_t type)
	It converts data.
float	pressure_conversion (int readValue)
	It converts pressure.
float	lws_conversion (int readValue)
	It converts leaf wetness.
float	humidity_conversion (int readValue)
	It converts humidity.
float	temperature_conversion (int readValue)
	It converts temperature.
void	getVaneDirection (float vane)
	It gets the direction of the wind.
float	temperature_conversion (int readValue, int precision)
	It converts the temperature returned by sensirion.
float	humidity_conversion (int readValue, int precision)
	It converts the humidity returned by sensirion.
float	sencera_conversion (int readValue)
	It converts the humidity returned by sencera.
float	mcp_conversion (int readValue)
	It converts the temperature returned by mcp.

---

Detailed Description

WaspSensorAgr Class.

WaspSensorAgr Class defines all the variables and functions used for managing the Agriculture Sensor Board

Definition at line 267 of file WaspSensorAgr.h.

---

Constructor & Destructor Documentation

WaspSensorAgr::WaspSensorAgr

(

)

class constructor

It initializes the different digital pins

Parameters:

void

Returns:

void

Definition at line 30 of file WaspSensorAgr.cpp.

References ANA0, DIGITAL1, DIGITAL2, DIGITAL3, DIGITAL4, DIGITAL5, DIGITAL6, DIGITAL7, DIGITAL8, digitalWrite(), INPUT, LOW, OUTPUT, pinMode(), SENS_PW_3V3, and SENS_PW_5V.

{
        pinMode(DIGITAL8,OUTPUT);
        pinMode(DIGITAL7,OUTPUT);
        pinMode(DIGITAL6,OUTPUT);
        pinMode(DIGITAL5,OUTPUT);
        pinMode(DIGITAL4,INPUT);
        pinMode(DIGITAL3,OUTPUT);
        pinMode(DIGITAL2,INPUT);        
        pinMode(DIGITAL1,OUTPUT);       
        pinMode(ANA0,OUTPUT);
        pinMode(SENS_PW_3V3,OUTPUT);
        pinMode(SENS_PW_5V,OUTPUT);
        pinMode(15, INPUT);
        pinMode(17, INPUT);
        pinMode(19, INPUT);
        
        digitalWrite(DIGITAL8,LOW);
        digitalWrite(DIGITAL7,LOW);
        digitalWrite(DIGITAL6,LOW);
        digitalWrite(DIGITAL5,LOW);
        digitalWrite(DIGITAL3,LOW);
        digitalWrite(DIGITAL1,LOW);
        digitalWrite(ANA0,LOW);
        digitalWrite(SENS_PW_3V3,LOW);
        digitalWrite(SENS_PW_5V,LOW);
}

Here is the call graph for this function:

---

Member Function Documentation

void WaspSensorAgr::setDigipot

(

float

value

)

[private]

It sets the Digipot threshold.

Parameters:

uint8_t

value : threshold

Returns:

void

Definition at line 626 of file WaspSensorAgr.cpp.

References B00000000, B0101000, TwoWire::begin(), TwoWire::beginTransmission(), WaspPWR::closeI2C(), delay(), TwoWire::endTransmission(), PWR, TwoWire::send(), and Wire.

Referenced by setAnemometerThreshold().

{

        float thres=0.0;
        uint8_t threshold=0;
        uint8_t address=B0101000;       
        
        thres=(3.3-value);
        thres *=128;
        thres /=3.3;
        threshold = (uint8_t) thres;
        Wire.begin();
        delay(100);
        Wire.beginTransmission(address);
        Wire.send(B00000000);
        Wire.send(threshold);
        Wire.endTransmission();
        PWR.closeI2C(); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

float WaspSensorAgr::readDendrometer

(

)

[private]

It reads from the dendrometer.

Returns:

the value returned by the sensor

Definition at line 298 of file WaspSensorAgr.cpp.

References TwoWire::available(), B0010110, B01010101, B10100001, TwoWire::begin(), TwoWire::beginTransmission(), WaspPWR::closeI2C(), conversion(), delay(), TwoWire::endTransmission(), PWR, TwoWire::receive(), TwoWire::requestFrom(), TwoWire::send(), and Wire.

Referenced by readValue().

{
        const byte address_ADC = B0010110;
        const byte dendro_channel = B10100001;
        byte data_dendro[3] = {0,0,0};
        float value_dendro = 0;
        
        Wire.begin();
        delay(100);
        delay(100);
        
        delay(100);
  
        Wire.beginTransmission(B0010110);
        Wire.send(dendro_channel);
        Wire.send(B01010101);
        Wire.endTransmission();

        delay(300);
  
        Wire.requestFrom(B0010110, 3);
  
        int i=0;
        while(Wire.available())
        {
                data_dendro[i]=Wire.receive();
                i++;
        }
        
        PWR.closeI2C(); 
  
        return value_dendro = conversion(data_dendro,0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

float WaspSensorAgr::readPT1000

(

)

[private]

It reads from the PT1000.

Returns:

the value returned by the sensor

Definition at line 332 of file WaspSensorAgr.cpp.

References TwoWire::available(), B0010110, B01010101, B10100000, TwoWire::begin(), TwoWire::beginTransmission(), WaspPWR::closeI2C(), conversion(), delay(), TwoWire::endTransmission(), PWR, TwoWire::receive(), TwoWire::requestFrom(), TwoWire::send(), and Wire.

Referenced by readValue().

{
        const byte address_ADC = B0010110;
        const byte pt1000_channel = B10100000;
        byte data_pt1000[3] = {0,0,0};
        float value_pt1000 = 0;
        
        Wire.begin();
        delay(100);
        delay(100);
        
        delay(100);

        Wire.beginTransmission(B0010110);
        Wire.send(pt1000_channel);
        Wire.send(B01010101);
        Wire.endTransmission();
  
        delay(300);
  
        Wire.requestFrom(B0010110, 3);

        int k=0;
        while(Wire.available())
        {
                data_pt1000[k]=Wire.receive();
                k++;
        }

        PWR.closeI2C(); 

        return value_pt1000 = conversion(data_pt1000,1);  
}

Here is the call graph for this function:

Here is the caller graph for this function:

float WaspSensorAgr::readRadiation

(

)

[private]

It reads from the radiation sensors.

Returns:

the value returned by the sensor

Definition at line 366 of file WaspSensorAgr.cpp.

References TwoWire::available(), B0010100, TwoWire::begin(), WaspPWR::closeI2C(), delay(), PWR, TwoWire::receive(), TwoWire::requestFrom(), and Wire.

Referenced by readValue().

{
        const byte address = B0010100;
        byte data_apogee[2] = {0,0};
        long val = 0;
        float val_def = 0;
        
        Wire.begin();
  
        delay(100);
  
        delay(50);
        
        Wire.requestFrom(B0010100, 2);
  
        int i = 0;
        while(Wire.available())
        {
                data_apogee[i] = Wire.receive();
                i++;
        }
  
// FIN DE LA LECTURA
        
        PWR.closeI2C(); 

// CONVERSIÓN A VALOR DE TENSIÓN
  
        val = long(data_apogee[1]) + long(data_apogee[0])*256;
    
        val_def = (val - 32769)*9;
        return val_def = val_def/65535;
}

Here is the call graph for this function:

Here is the caller graph for this function:

float WaspSensorAgr::readWatermark

(

uint8_t

sens

)

[private]

It reads from the Watermark.

Parameters:

uint8_t

sens : the Watermark on use

Returns:

the value returned by the sensor

Definition at line 400 of file WaspSensorAgr.cpp.

References digitalRead(), digitalWrite(), INPUT, LOW, millis(), pinMode(), SENS_AGR_WATERMARK_1, SENS_AGR_WATERMARK_2, SENS_AGR_WATERMARK_3, and SENS_MUX_SEL.

Referenced by readValue().

{
        uint8_t pin=0;
        int value_watermark = 0;
        int previous_value_watermark = 0;
        int counter_watermark = 0;
        unsigned long start = 0;
        float freq = 0;
        
        pinMode(15, INPUT);
        pinMode(17, INPUT);
        pinMode(19, INPUT);
        
        digitalWrite(SENS_MUX_SEL,LOW);
        
        switch( sens )
        {
                case SENS_AGR_WATERMARK_1:      pin=17;
                                                break;
                case SENS_AGR_WATERMARK_2:      pin=19;
                                                break;
                case SENS_AGR_WATERMARK_3:      pin=15;
                                                break;
        }
        
        counter_watermark = 0;
        start = millis();
        while(counter_watermark < 2000)
        {
                previous_value_watermark = value_watermark;
                value_watermark = digitalRead(pin);
    
                if((previous_value_watermark ==1)&&(value_watermark == 0))
                {
                        counter_watermark++;
                }
        }
  
        return freq = 2000000 / float((millis() - start));
}

Here is the call graph for this function:

Here is the caller graph for this function:

float WaspSensorAgr::readSensirion

(

uint8_t

parameter

)

[private]

It reads from the sensirion.

Parameters:

uint8_t

parameter : TEMPERATURE or HUMIDITY

Returns:

the value returned by the sensor

Definition at line 441 of file WaspSensorAgr.cpp.

References B00000011, B00000101, delayMicroseconds(), digitalRead(), digitalWrite(), HIGH, humidity_conversion(), INPUT, LOW, MSBFIRST, OUTPUT, pinMode(), SENS_CLK, SENS_DATA, SENS_PREC_HIGH, SENSIRION_HUM, SENSIRION_TEMP, shiftOut(), and temperature_conversion().

Referenced by readValue().

{
        int ack = 0;
        int val_read = 0;
        int ack2, ack3, i = 0;
        
        const byte HUMIDITY = B00000101;
        const byte TEMPERATURE = B00000011;
        
        

        if( parameter==SENSIRION_TEMP ) parameter=TEMPERATURE;
        else if( parameter==SENSIRION_HUM ) parameter=HUMIDITY;
                
  //************************************* 
  // PRIMER CICLO DE TRANSMISIÓN (START)
  
        pinMode(SENS_DATA,  OUTPUT);
        pinMode(SENS_CLK, OUTPUT);
        digitalWrite(SENS_DATA,  HIGH);
        digitalWrite(SENS_CLK, HIGH);
        delayMicroseconds(1);
        digitalWrite(SENS_DATA,  LOW);
        digitalWrite(SENS_CLK, LOW);
        delayMicroseconds(1);
        digitalWrite(SENS_CLK, HIGH);
        digitalWrite(SENS_DATA,  HIGH);
        delayMicroseconds(1);
        digitalWrite(SENS_CLK, LOW);

  //***************************************
  // escribir el comando (los 3 primeros bits deben ser la direccion (siempre 000), y los ultimos 5 bits son el comando)

        shiftOut(SENS_DATA, SENS_CLK, MSBFIRST, parameter);  //parameter: B00000011 para temperatura y B00000101 para Humedad
        digitalWrite(SENS_CLK, HIGH);
        pinMode(SENS_DATA, INPUT);

        ack = digitalRead(SENS_DATA);
        while(ack == HIGH)
        {
                ack = digitalRead(SENS_DATA);
        }

  
        digitalWrite(SENS_CLK, LOW);
  
        ack = digitalRead(SENS_DATA);
        while(ack == LOW)
        {
                ack = digitalRead(SENS_DATA);
        }
  
  //****************************************
  //Espera a que la conversión esté completa
  
        ack = digitalRead(SENS_DATA);
        while(ack == HIGH)
        {
                ack = digitalRead(SENS_DATA);
        }
  
  //*****************************************
  //Obtención de los 8 bits más significativos

        for(int i = 0; i < 8; i++)
        {
                digitalWrite(SENS_CLK, HIGH);
                val_read = (val_read * 2) + digitalRead(SENS_DATA);
                digitalWrite(SENS_CLK, LOW);
        }
  
        ack = digitalRead(SENS_DATA);
        while(ack == LOW)
        {
                ack = digitalRead(SENS_DATA);
        }
  
  //****************************************
  //ACK del micro
        pinMode(SENS_DATA, OUTPUT);
        digitalWrite(SENS_DATA, LOW);
        delayMicroseconds(1);
        digitalWrite(SENS_CLK, HIGH);
        delayMicroseconds(400);
        digitalWrite(SENS_CLK, LOW);
        pinMode(SENS_DATA, INPUT);
  
  
  //***************************************
  //Lectura de los 8 bits menos significativos
  
        for(int i = 0; i < 8; i++)
        {
                digitalWrite(SENS_CLK, HIGH);
                val_read = val_read * 2 + digitalRead(SENS_DATA);
                digitalWrite(SENS_CLK, LOW);
        }
  
  //**************************************
  //Prescindimos del byte CRC  
  
        pinMode(SENS_DATA, OUTPUT);
        digitalWrite(SENS_DATA, HIGH);
        digitalWrite(SENS_CLK, HIGH);
        delayMicroseconds(400);
        digitalWrite(SENS_CLK, LOW);
  
        if( parameter==TEMPERATURE ) return temperature_conversion(val_read,SENS_PREC_HIGH);
        else if( parameter==HUMIDITY ) return humidity_conversion(val_read,SENS_PREC_HIGH);

        digitalWrite(SENS_DATA, LOW);
        

} 

Here is the call graph for this function:

Here is the caller graph for this function:

uint16_t WaspSensorAgr::readPluviometer

(

)

[private]

It reads from the pluviometer.

Returns:

the value returned by the sensor

Definition at line 602 of file WaspSensorAgr.cpp.

References delay(), DIGITAL2, digitalRead(), and millis().

Referenced by readValue().

{
        int reading_pluviometer = 0;
        int previous_reading_pluviometer = 0;
        int value_pluviometer = 0;
        unsigned long start_pluviometer=0;

        value_pluviometer = 0;
        start_pluviometer = millis();
        while((millis()-start_pluviometer)<=3000)
        {
                previous_reading_pluviometer = reading_pluviometer;
                reading_pluviometer = digitalRead(DIGITAL2);
    
                if((previous_reading_pluviometer == 1)&&(reading_pluviometer == 0))
                {
                        value_pluviometer++;
                }
        }
        delay(100);
  
        return value_pluviometer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

float WaspSensorAgr::conversion	(	byte	data_input[3],
		uint8_t	type
	)			[private]

It converts data.

Parameters:

	byte	data_input : the data to convert
	uint8_t	type : temperature(1) or dendrometer(0)

Returns:

the value converted

Definition at line 647 of file WaspSensorAgr.cpp.

References B00000001, B00000011, and B00111111.

Referenced by readDendrometer(), and readPT1000().

{
        long val = 0;
        float val_def = 0;
        int signo = 0;
        int overflow = 0;
        float Vcc = 3.3;
        float R1           = 1005.0; 
        float R2           = 1005.0;
        float R3           = 1005.0;
        float Rx           = 0.0;
        float tempPt       = 0.0;
        float equis        = 0.0;
  
        signo = int(data_input[0] >> 7);
        overflow = int((data_input[0] >> 6)&B00000001);

        val = long((data_input[2] >> 6)&B00000011) + long(data_input[1])*4 + long((data_input[0])&B00111111)*1024;

  
        if (signo == 1)
        {
                if (overflow == 1)
                {
      //OVERFLOW High
                        val_def = 2;
                }
                else
                {
                        val_def = val*1.5;
                        val_def = val_def/65535;
                }
        }
        else
        {
                if (overflow == 0)
                {
      //OVERFLOW LOW
                        val_def = -2;
                }
                else
                {
                        val_def = -(65535 - val)*1.5;
                        val_def = val_def/65535;
                }
        }

        if( type==1 ){
                Rx = (Vcc*R2*R3 + val_def*R3*(R1+R2)) / (Vcc*R1 - val_def*(R1+R2));
                equis = (Rx - 1001.52) / 1351.99;
                Rx = equis * 1494.46 + 996.04;
                tempPt = (Rx-1000)/3.9083;
                return(tempPt);
        }
        else if( type==0) return ( (val_def * 11000)/1000.0 );
}

Here is the caller graph for this function:

float WaspSensorAgr::pressure_conversion

(

int

readValue

)

[private]

It converts pressure.

Parameters:

int

readValue : the data to convert

Returns:

the value converted

Definition at line 706 of file WaspSensorAgr.cpp.

Referenced by readValue().

{
        float pressure = 0;
   
        pressure = float(readValue) * 5000 / 1023;
   
        pressure = (((pressure + 270) / 5000) + 0.095 ) / 0.0088;
   
        return(pressure);
}

Here is the caller graph for this function:

float WaspSensorAgr::lws_conversion

(

int

readValue

)

[private]

It converts leaf wetness.

Parameters:

int

readValue : the data to convert

Returns:

the value converted

Definition at line 717 of file WaspSensorAgr.cpp.

{
        float lws = 0;
   
        lws = float(readValue) * 3.3 / 1023;
   
        return(lws);
   
}

float WaspSensorAgr::humidity_conversion

(

int

readValue

)

[private]

It converts humidity.

Parameters:

int

readValue : the data to convert

Returns:

the value converted

Definition at line 727 of file WaspSensorAgr.cpp.

Referenced by readSensirion().

{
        float humidity = 0;
   
        humidity = float(readValue) * 5000 / 1023;
   
        humidity = (humidity - 800) / 31;
   
        return(humidity);
   
}

Here is the caller graph for this function:

float WaspSensorAgr::temperature_conversion

(

int

readValue

)

[private]

It converts temperature.

Parameters:

int

readValue : the data to convert

Returns:

the value converted

Definition at line 739 of file WaspSensorAgr.cpp.

Referenced by readSensirion().

{
        float temperature = 0;
   
        temperature = float(readValue) * 3300 / 1023;
   
        temperature = (temperature - 500) / 10;
   
        return(temperature);
   
}

Here is the caller graph for this function:

void WaspSensorAgr::getVaneDirection

(

float

vane

)

[private]

It gets the direction of the wind.

Parameters:

float

vane : the voltage got from the vane

Returns:

nothing

Definition at line 751 of file WaspSensorAgr.cpp.

References SENS_AGR_VANE_E, SENS_AGR_VANE_ENE, SENS_AGR_VANE_ESE, SENS_AGR_VANE_N, SENS_AGR_VANE_NE, SENS_AGR_VANE_NNE, SENS_AGR_VANE_NNW, SENS_AGR_VANE_NW, SENS_AGR_VANE_S, SENS_AGR_VANE_SE, SENS_AGR_VANE_SSE, SENS_AGR_VANE_SSW, SENS_AGR_VANE_SW, SENS_AGR_VANE_W, SENS_AGR_VANE_WNW, SENS_AGR_VANE_WSW, and vane_direction.

Referenced by readValue().

{
        if( vane<0.25 ) vane_direction=SENS_AGR_VANE_ESE;
        else if( vane>=0.25 && vane<0.28 ) vane_direction=SENS_AGR_VANE_ENE;
        else if( vane>=0.28 && vane<0.35 ) vane_direction=SENS_AGR_VANE_E;
        else if( vane>=0.35 && vane<0.5 ) vane_direction=SENS_AGR_VANE_SSE;
        else if( vane>=0.5 && vane<0.65 ) vane_direction=SENS_AGR_VANE_SE;
        else if( vane>=0.65 && vane<0.85 ) vane_direction=SENS_AGR_VANE_SSW;
        else if( vane>=0.85 && vane<1.1 ) vane_direction=SENS_AGR_VANE_S;
        else if( vane>=1.1 && vane<1.38 ) vane_direction=SENS_AGR_VANE_NNE;
        else if( vane>=1.38 && vane<1.6 ) vane_direction=SENS_AGR_VANE_NE;
        else if( vane>=1.6 && vane<1.96 ) vane_direction=SENS_AGR_VANE_WSW;
        else if( vane>=1.96 && vane<2.15 ) vane_direction=SENS_AGR_VANE_SW;
        else if( vane>=2.15 && vane<2.35 ) vane_direction=SENS_AGR_VANE_NNW;
        else if( vane>=2.35 && vane<2.6 ) vane_direction=SENS_AGR_VANE_N;
        else if( vane>=2.6 && vane<2.8 ) vane_direction=SENS_AGR_VANE_WNW;
        else if( vane>=2.8 && vane<3.1 ) vane_direction=SENS_AGR_VANE_W;
        else if( vane>=3.1 ) vane_direction=SENS_AGR_VANE_NW;
}

Here is the caller graph for this function:

float WaspSensorAgr::temperature_conversion	(	int	readValue,
		int	precision
	)			[private]

It converts the temperature returned by sensirion.

Parameters:

	int	readValue : value returned by sensirion
	int	precision : precission bits

Returns:

the converted value

Definition at line 556 of file WaspSensorAgr.cpp.

References SENS_PREC_HIGH, and SENS_PREC_LOW.

{
        float temperature = 0;
        float d1 = -39.7;
        float d2 = 0;
        
        float aux=0;
  
        switch(precision)
        {
                case SENS_PREC_HIGH:    d2 = 0.01;
                                        temperature = d1 + (d2 * float(readValue));
                                        break;    
                case SENS_PREC_LOW:     d2 = 0.04;
                                        temperature = d1 + (d2 * float(readValue));
                                        break;
        }
  
        return(temperature);
}

float WaspSensorAgr::humidity_conversion	(	int	readValue,
		int	precision
	)			[private]

It converts the humidity returned by sensirion.

Parameters:

	int	readValue : value returned by sensirion
	int	precision : precission bits

Returns:

the converted value

Definition at line 578 of file WaspSensorAgr.cpp.

References SENS_PREC_HIGH, and SENS_PREC_LOW.

{
        float humidity = 0;
        float c1 = -2.0468;
        float c2 = 0;
        float c3 = 0;
  
        switch(precision)
        {
                case SENS_PREC_HIGH:    c2 = 0.0367;
                                        c3 = -1.5955e-6;
                                        humidity = c1 + (c2 * float(readValue)) + (c3 * float(readValue) * float(readValue));
                                        break;

                case SENS_PREC_LOW:     c2 = 0.5872;
                                        c3 = -4.0845e-4;
                                        humidity = c1 + (c2 * float(readValue)) + (c3 * float(readValue) * float(readValue));
                                        break;

        }
  
        return(humidity);
}

float WaspSensorAgr::sencera_conversion

(

int

readValue

)

[private]

It converts the humidity returned by sencera.

Parameters:

int

readValue : value returned by sencera

Returns:

the converted value

Definition at line 771 of file WaspSensorAgr.cpp.

Referenced by readValue().

{
        float humidity = 0;
   
        humidity = float(readValue) * 5000 / 1023;
   
        humidity = (humidity - 800) / 31;
   
        return(humidity);
   
}

Here is the caller graph for this function:

float WaspSensorAgr::mcp_conversion

(

int

readValue

)

[private]

It converts the temperature returned by mcp.

Parameters:

int

readValue : value returned by mcp

Returns:

the converted value

Definition at line 783 of file WaspSensorAgr.cpp.

Referenced by readValue().

{
        float temperature = 0;
   
        temperature = float(readValue) * 3300 / 1023;
   
        temperature = (temperature - 500) / 10;
   
        return(temperature);
   
}

Here is the caller graph for this function:

void WaspSensorAgr::setBoardMode

(

uint8_t

mode

)

It sets board power mode, setting ON/OFF 3v3 and 5V switches.

Parameters:

uint8_t

mode : SENS_ON or SENS_OFF

Returns:

void

Definition at line 60 of file WaspSensorAgr.cpp.

References delay(), digitalWrite(), HIGH, LOW, RTC, RTC_ON, SENS_OFF, SENS_ON, SENS_PW_3V3, SENS_PW_5V, and WaspRTC::setMode().

{
        delay(1000);
        
        //FIXME
//      digitalWrite(SENS_SWITCH_3,HIGH);
        
        switch( mode )
        {
                case    SENS_ON :       digitalWrite(SENS_PW_3V3,HIGH);
                                        digitalWrite(SENS_PW_5V,HIGH);
                                        // Sets RTC on to enable I2C
                                        RTC.setMode(RTC_ON);
                                        break;
                case    SENS_OFF:       digitalWrite(SENS_PW_3V3,LOW);
                                        digitalWrite(SENS_PW_5V,LOW);
                                        break;
        }
}

Here is the call graph for this function:

void WaspSensorAgr::setSensorMode	(	uint8_t	mode,
		uint16_t	sensor
	)

It sets ON/OFF the different sensor switches.

Parameters:

	uint8_t	mode : SENS_ON or SENS_OFF
	uint16_t	sensor : the sensor to set ON/OFF

Returns:

void

Definition at line 81 of file WaspSensorAgr.cpp.

References digitalWrite(), HIGH, LOW, SENS_AGR_ANEMOMETER, SENS_AGR_DENDROMETER, SENS_AGR_HUMIDITY, SENS_AGR_LEAF_WETNESS, SENS_AGR_PRESSURE, SENS_AGR_PT1000, SENS_AGR_RADIATION, SENS_AGR_SENSIRION, SENS_AGR_TEMPERATURE, SENS_AGR_VANE, SENS_AGR_WATERMARK_1, SENS_AGR_WATERMARK_2, SENS_AGR_WATERMARK_3, SENS_OFF, SENS_ON, SENS_SWITCH_1, SENS_SWITCH_2, SENS_SWITCH_3, and SENS_SWITCH_4.

{       
        if( mode==SENS_ON )
        {
                switch( sensor )
                {
                        case    SENS_AGR_PRESSURE:      digitalWrite(SENS_SWITCH_1,HIGH);
                                                        break;
                        case    SENS_AGR_WATERMARK_1:   digitalWrite(SENS_SWITCH_2,HIGH);
                                                        break;
                        case    SENS_AGR_WATERMARK_2:   digitalWrite(SENS_SWITCH_2,HIGH);
                                                        break;
                        case    SENS_AGR_WATERMARK_3:   digitalWrite(SENS_SWITCH_2,HIGH);
                                                        break;                          
                        case    SENS_AGR_ANEMOMETER:    digitalWrite(SENS_SWITCH_3,HIGH);
                                                        break;
                        case    SENS_AGR_VANE   :       digitalWrite(SENS_SWITCH_3,HIGH);
                                                        break;
                        case    SENS_AGR_DENDROMETER:   digitalWrite(SENS_SWITCH_4,HIGH);
                                                        break;
                        case    SENS_AGR_PT1000 :       digitalWrite(SENS_SWITCH_4,HIGH);
                                                        break;
                        case    SENS_AGR_LEAF_WETNESS:  digitalWrite(SENS_SWITCH_4,HIGH);
                                                        break;
                        case    SENS_AGR_TEMPERATURE:   digitalWrite(SENS_SWITCH_4,HIGH);
                                                        break;
                        case    SENS_AGR_HUMIDITY:      digitalWrite(SENS_SWITCH_4,HIGH);
                                                        break;
                        case    SENS_AGR_RADIATION:     digitalWrite(SENS_SWITCH_4,HIGH);
                                                        break;
                        case    SENS_AGR_SENSIRION:     digitalWrite(SENS_SWITCH_4,HIGH);
                                                        break;
                }
        }
        
        if( mode==SENS_OFF )
        {
                switch( sensor )
                {
                        case    SENS_AGR_PRESSURE:      digitalWrite(SENS_SWITCH_1,LOW);
                                                        break;
                        case    SENS_AGR_WATERMARK_1:   digitalWrite(SENS_SWITCH_2,LOW);
                                                        break;
                        case    SENS_AGR_WATERMARK_2:   digitalWrite(SENS_SWITCH_2,LOW);
                                                        break;
                        case    SENS_AGR_WATERMARK_3:   digitalWrite(SENS_SWITCH_2,LOW);
                                                        break;                          
                        case    SENS_AGR_ANEMOMETER:    digitalWrite(SENS_SWITCH_3,LOW);
                                                        break;
                        case    SENS_AGR_VANE   :       digitalWrite(SENS_SWITCH_3,LOW);
                                                        break;
                        case    SENS_AGR_DENDROMETER:   digitalWrite(SENS_SWITCH_4,LOW);
                                                        break;
                        case    SENS_AGR_PT1000 :       digitalWrite(SENS_SWITCH_4,LOW);
                                                        break;
                        case    SENS_AGR_LEAF_WETNESS:  digitalWrite(SENS_SWITCH_4,LOW);
                                                        break;
                        case    SENS_AGR_TEMPERATURE:   digitalWrite(SENS_SWITCH_4,LOW);
                                                        break;
                        case    SENS_AGR_HUMIDITY:      digitalWrite(SENS_SWITCH_4,LOW);
                                                        break;
                        case    SENS_AGR_RADIATION:     digitalWrite(SENS_SWITCH_4,LOW);
                                                        break;
                        case    SENS_AGR_SENSIRION:     digitalWrite(SENS_SWITCH_4,LOW);
                                                        break;
                }
        }
}

Here is the call graph for this function:

float WaspSensorAgr::readValue

(

uint16_t

sensor

)

It reads the value measured by the sensor.

Parameters:

uint16_t

sensor : the sensor to read the value from

Returns:

the value measured by the sensor (range [0-3.3] Volts)

Definition at line 151 of file WaspSensorAgr.cpp.

{
        return readValue(sensor,0);
}

float WaspSensorAgr::readValue	(	uint16_t	sensor,
		uint8_t	type
	)

It reads the value measured by the sensor.

Parameters:

	uint16_t	sensor : the sensor to read the value from
	uint8_t	type : the type to read

Returns:

the value measured by the sensor (range [0-3.3] Volts)

Definition at line 157 of file WaspSensorAgr.cpp.

References ANALOG2, ANALOG3, ANALOG4, ANALOG5, ANALOG6, ANALOG7, analogRead(), digitalWrite(), getVaneDirection(), HIGH, LOW, mcp_conversion(), pressure_conversion(), readDendrometer(), readPluviometer(), readPT1000(), readRadiation(), readSensirion(), readWatermark(), sencera_conversion(), SENS_AGR_ANEMOMETER, SENS_AGR_DENDROMETER, SENS_AGR_HUMIDITY, SENS_AGR_LEAF_WETNESS, SENS_AGR_PLUVIOMETER, SENS_AGR_PRESSURE, SENS_AGR_PT1000, SENS_AGR_RADIATION, SENS_AGR_SENSIRION, SENS_AGR_TEMPERATURE, SENS_AGR_VANE, SENS_AGR_WATERMARK_1, SENS_AGR_WATERMARK_2, SENS_AGR_WATERMARK_3, SENS_MUX_SEL, SENSIRION_HUM, and SENSIRION_TEMP.

{
        float aux=0;
        uint16_t aux2=0;
        
        switch( sensor )
        {
                case    SENS_AGR_PRESSURE:      aux2=analogRead(ANALOG3);
                                                aux=pressure_conversion(aux2); // KPa
                                                break;
                case    SENS_AGR_WATERMARK_1:   aux=readWatermark(SENS_AGR_WATERMARK_1); // 50Hz - 200cbar || 10KHz - 0cbar
                                                break;
                case    SENS_AGR_WATERMARK_2:   aux=readWatermark(SENS_AGR_WATERMARK_2); // 50Hz - 200cbar || 10KHz - 0cbar
                                                break;
                case    SENS_AGR_WATERMARK_3:   aux=readWatermark(SENS_AGR_WATERMARK_3); // 50Hz - 200cbar || 10KHz - 0cbar
                                                break;
                case    SENS_AGR_ANEMOMETER:    aux2=analogRead(ANALOG7);
                                                aux = float(aux2) * 3.3 * 2.4 / (1023*0.03); // km/h
                                                break;
                case    SENS_AGR_VANE   :       aux2=analogRead(ANALOG5);
                                                aux=(aux2*3.3)/1023; // Volts
                                                getVaneDirection(aux); // Direction
                                                break;
                case    SENS_AGR_DENDROMETER:   aux=readDendrometer(); //mm
                                                break;
                case    SENS_AGR_PT1000 :       aux=readPT1000(); // º Celsius
                                                break;
                case    SENS_AGR_LEAF_WETNESS:  digitalWrite(SENS_MUX_SEL,HIGH); // Volts
                                                aux2=analogRead(ANALOG6);
                                                aux=(aux2*3.3)/1023;
                                                digitalWrite(SENS_MUX_SEL, LOW);
                                                break;
                case    SENS_AGR_TEMPERATURE:   digitalWrite(SENS_MUX_SEL,HIGH);
                                                aux2=analogRead(ANALOG4);
                                                aux=mcp_conversion(aux2); // ºCelsius
                                                digitalWrite(SENS_MUX_SEL, LOW);
                                                break;
                case    SENS_AGR_HUMIDITY:      digitalWrite(SENS_MUX_SEL,HIGH);
                                                aux2=analogRead(ANALOG2);
                                                aux=sencera_conversion(aux2); // %Hum
                                                digitalWrite(SENS_MUX_SEL, LOW);
                                                break;
                case    SENS_AGR_RADIATION:     aux=readRadiation(); //mV
                                                break;
                case    SENS_AGR_SENSIRION:     if( type==SENSIRION_TEMP ) aux=readSensirion(SENSIRION_TEMP); // ºCelsius
                                                else if( type==SENSIRION_HUM ) aux=readSensirion(SENSIRION_HUM);// %Hum
                                                break;
                case    SENS_AGR_PLUVIOMETER:   aux2=readPluviometer();
                                                aux=float(aux2) * 0.2794 * 20; // mm/min
                                                break;  
        }
        return  aux;
}

Here is the call graph for this function:

void WaspSensorAgr::setAnemometerThreshold

(

float

threshold

)

It sets threshold configuring digipots.

Parameters:

	uint8_t	sensor : specifies the socket to set the threshold to ('SENS_SOCKETX')
	float	threshold : the threshold to set (0-3.3V)

Returns:

void

Definition at line 216 of file WaspSensorAgr.cpp.

References setDigipot().

{
        threshold =  threshold*0.03/(2.4);
        setDigipot(threshold);
}

Here is the call graph for this function:

void WaspSensorAgr::sleepAgr	(	const char *	time2wake,
		uint8_t	offset,
		uint8_t	mode,
		uint8_t	option
	)

It sleeps Waspmote enabling the switches required for the agriculture board.

Parameters:

	const	char* time2wake : string that indicates the time to wake up. It looks like "dd:hh:mm:ss"
	uint8_t	offset : RTC_OFFSET or RTC_ABSOLUTE
	uint8_t	mode : RTC_ALM1_MODE1, RTC_ALM1_MODE2, RTC_ALM1_MODE3, RTC_ALM1_MODE4 or RTC_ALM1_MODE5
	uint8_t	option : ALL_OFF, SENS_OFF, UART0_OFF, UART1_OFF, BAT_OFF or RTC_OFF

Returns:

void

Definition at line 254 of file WaspSensorAgr.cpp.

{
        sleepAgr(time2wake, offset, mode, option, 0);
}

void WaspSensorAgr::sleepAgr	(	const char *	time2wake,
		uint8_t	offset,
		uint8_t	mode,
		uint8_t	option,
		uint8_t	agr_interrupt
	)

It sleeps Waspmote enabling the switches required for the agriculture board.

Parameters:

	const	char* time2wake : string that indicates the time to wake up. It looks like "dd:hh:mm:ss"
	uint8_t	offset : RTC_OFFSET or RTC_ABSOLUTE
	uint8_t	mode : RTC_ALM1_MODE1, RTC_ALM1_MODE2, RTC_ALM1_MODE3, RTC_ALM1_MODE4 or RTC_ALM1_MODE5
	uint8_t	option : ALL_OFF, SENS_OFF, UART0_OFF, UART1_OFF, BAT_OFF or RTC_OFF
	uint8_t	agr_interrupt : specifies the sensor we are enabling before going sleep (Anemometer and Pluviometer)

Returns:

void

Definition at line 259 of file WaspSensorAgr.cpp.

References ANE_INT, WaspRTC::close(), digitalWrite(), enableInterrupts(), HIGH, LOW, PLV_INT, PWR, RTC, SENS_AGR_ANEMOMETER, SENS_AGR_PLUVIOMETER, SENS_DATA, SENS_MUX_SEL, SENS_SWITCH_1, SENS_SWITCH_2, SENS_SWITCH_3, SENS_SWITCH_4, WaspRTC::setAlarm1(), WaspPWR::switchesOFF(), and WaspPWR::switchesON().

{
        // Set RTC alarme to wake up from Sleep Power Down Mode
        RTC.setAlarm1(time2wake,offset,mode);
        RTC.close();
        digitalWrite(SENS_SWITCH_1, LOW);
        digitalWrite(SENS_SWITCH_2, LOW);
        digitalWrite(SENS_SWITCH_4, LOW);
        digitalWrite(SENS_MUX_SEL, LOW);
        digitalWrite(SENS_DATA, LOW);

        PWR.switchesOFF(option);

        if (agr_interrupt && SENS_AGR_ANEMOMETER)
        {
                digitalWrite(SENS_SWITCH_3, HIGH);
                enableInterrupts(ANE_INT);
        }
        else
        {
                digitalWrite(SENS_SWITCH_3, LOW);
        }

        if (agr_interrupt && SENS_AGR_PLUVIOMETER)
        {
                enableInterrupts(PLV_INT);
        }


        set_sleep_mode(SLEEP_MODE_PWR_DOWN);
        sleep_enable();
        sleep_mode();
        sleep_disable();
        PWR.switchesON(option);
}

Here is the call graph for this function:

void WaspSensorAgr::attachInt

(

uint8_t

sens

)

It switches off the general switch enabling RTC interruption for the Agriculture Board.

Parameters:

	const	char* time2wake : string that indicates the time to wake up. It looks like "dd:hh:mm:ss"
	uint8_t	offset : RTC_OFFSET or RTC_ABSOLUTE
	uint8_t	mode : RTC_ALM1_MODE1, RTC_ALM1_MODE2, RTC_ALM1_MODE3, RTC_ALM1_MODE4 or RTC_ALM1_MODE5

Returns:

void

See also:

sleep(uint8_t option), sleep(uint8_t timer, uint8_t option), deepSleep(const char* time2wake, uint8_t offset, uint8_t mode, uint8_t option)

Definition at line 227 of file WaspSensorAgr.cpp.

References ANE_INT, enableInterrupts(), PLV_INT, SENS_AGR_ANEMOMETER, and SENS_AGR_PLUVIOMETER.

{
        switch( sens )
        {
                case SENS_AGR_ANEMOMETER:       enableInterrupts(ANE_INT);
                                                break;
                case SENS_AGR_PLUVIOMETER:      enableInterrupts(PLV_INT);
                                                break;
        }
}

Here is the call graph for this function:

void WaspSensorAgr::detachInt

(

uint8_t

sens

)

It attaches the interruption.

Parameters:

uint8_t

sens: specifies the sensor (ANEMOMETER or PLUVIOMETER) which detaches the interruption

Returns:

void

Definition at line 243 of file WaspSensorAgr.cpp.

References ANE_INT, disableInterrupts(), PLV_INT, SENS_AGR_ANEMOMETER, and SENS_AGR_PLUVIOMETER.

{
        switch( sens )
        {
                case SENS_AGR_ANEMOMETER:       disableInterrupts(ANE_INT);
                                                break;
                case SENS_AGR_PLUVIOMETER:      disableInterrupts(PLV_INT);
                                                break;
        }
}

Here is the call graph for this function:

---

Field Documentation

uint16_t WaspSensorAgr::vane_direction

Variable : specifies the wind direction.

Definition at line 394 of file WaspSensorAgr.h.

Referenced by getVaneDirection().

---

The documentation for this class was generated from the following files:

• WaspSensorAgr.h
• WaspSensorAgr.cpp