Experimente con las plantas y elija lo que sea mejor para estas. Lleve un registro del crecimiento de las plantas. Tasas de cultivo en tiempo real y alertas de emergencia.
Este proyecto demuestra cómo construir una connexión SigFox, SigFy v1 y v2, una herramienta agrícola que mide continuamente datos agrícolas como ser temperatura, humedad, niveles de gas, humedad, intensidad de luz, altura de la planta y también detecta plagas que causan enfermedades o actividades como la tala de árboles y hace que los datos en tiempo real estén disponibles para los usuarios en línea. También se puede utilizar para controlar la salud de los agricultores o de las personas. También pone a disposición de los agricultores las tasas actuales de cultivo y semillas a través de su interface.
El sistema se puede implementar en aldeas remotas con una configuración única, y se puede dejar que se ejecute por sí solo, recopilando datos automáticamente sin la necesidad de que los usuarios estén presentes. Se pueden colocar múltiples dispositivos SigFy en una aldea para recopilar muchos puntos de datos, creando eventualmente una topología de malla en estrella con estaciones base Sigfox para analizar datos complejos.
Los datos de medición se envían a la nube thethings.io a través de la conectividad de red Sigfox, habilitada por el módulo ATA8520 en Arduino MKRFOX1200, y se pueden ver en línea a través del panel de control de thethings.io IoT y otros servicios se utilizan para enviar notificaciones por correo electrónico a los usuarios cuando los valores alcanzan un nivel crítico.
Resumen técnico
Mientras estaba soñando despierto, pensé en esta idea para usar sensores para registrar la altura de los cultivos y detectar signos tempranos de enfermedades y también sin usar 3G, 4G o 5G , por lo que casi no hay huella de carbono .
Tuve que aprender sobre SigFox red, un protocolo de comunicación estándar de radio 0G , aunque la velocidad y la capacidad de transmisión de datos es todavía una limitación, lo hace que sea fiable y perfecto para la interface de electrodomésticos. Actualmente tiene un límite de carga útil de 12 bytes para cada mensaje y cada día puede haber hasta 140 mensajes .Tome nota, puede usar 140 mensajes por día, si lo permuta, significa que puede enviar muchos datos de sensores diferentes a intervalos frecuentes, por ejemplo, desea enviar datos de 6 sensores y cada dato se enviará después de un intervalo de 10 minutos para que pueda hacer que su dispositivo utilice una técnica de iteración para enviar los primeros datos de tres sensores y luego la segunda vez enviar los datos de los cinco sensores restantes. Por lo tanto, puede tener múltiples combinaciones para enviar todos los datos del sensor a intervalos frecuentes. Yo utilicé esta misma técnica.
Una agricultura sostenible
Con el aumento de la población, es importante un método agrícola sostenible. Es muy importante analizar lo que está sucediendo en la granja, si un agricultor tuviera los medios para saber cómo se ve afectado el crecimiento de la planta y utiliza diferentes técnicas para cultivar, entonces también podría predecir qué tipo de métodos y químicos seguros y la cantidad correcta de agua se requiere para un rendimiento máximo. También es muy necesario que los agricultores cultiven con conocimiento para que obtengan el máximo rendimiento y restauren la calidad próspera de la naturaleza. En mi país, India, los agricultores sufren debido a la falta de uso de dispositivos de IoT en la agricultura.
Detección de determinados organismos beneficiosos y nocivos mediante análisis de sonido:
Las flores pueden escuchar el zumbido de las abejas, y eso hace que su néctar sea más dulce
Los agricultores están usando muchos productos químicos para aumentar el rendimiento de su granja, pero tendemos a olvidar que debido al uso excesivo de esos pesticidas, insecticidas y abonos inorgánicos, los agentes de polinización cruzada, los artrópodos (el 90% de los organismos vivos que se encuentran en la tierra son insectos ) no sean atraídos por esas plantas o mueran debido a la excesiva exposición química y la contaminación. Más de 2000 insectos polinizadores se han extinguido en la actualidad y solo 500 quedan extinguidos si no se protegen. También necesitamos detectar enfermedades en los cultivos lo antes posible para evitar que se propaguen en la granja. Para resolver este problema, pensé por qué no decirle a los agricultores que usen productos químicos solo si hay patrones de crecimiento malos o plagas dañinas, hoy en día incluso si no hay ninguna enfermedad, los agricultores rocían químicos inútilmente y matan insectos útiles como las abejas. También detectará ciertos agentes polinizadores y con qué frecuencia se encuentran en los campos. También puede detectar animales grandes que destruyen el cultivo solo por su voz y frecuencia.
Monitoreo de la salud de los agricultores y la aldea
Los agricultores indios hacen un duro trabajo en su granja, con este dispositivo pueden incluso controlar su pulso y problemas relacionados con la salud. El dispositivo también detectaría insectos dañinos como los mosquitos y haría que los aldeanos fueran conscientes de la reproducción de insectos mortales, la misma técnica de análisis de sonido resolvería este problema. En caso de incendio o fuga de gas cercana, el dispositivo alertaría a todos.
Detener la deforestación
Hay muchas talas ilegales de árboles, por lo que mi dispositivo informaría a las autoridades interesadas sobre la tala de árboles utilizando una técnica de análisis de sonido, en particular, detectaría el tono y la frecuencia de las herramientas de corte de madera que se utilizan.
SigFy v1.0 (versión 1.0)
Agricultura sostenible
Estoy usando un sensor de distancia ultrasónico para detectar la altura de los cultivos desde el suelo. Entonces, cada vez que se inicia el dispositivo, el sensor de distancia se calibra a sí mismo y establece la distancia del dispositivo desde el suelo para las mediciones del crecimiento de las plantas y usa este valor para encontrar la altura relativa de la planta desde el suelo (para que pueda arreglar este dispositivo cuando siembre las semillas). Aquí está el código para medir la altura de la planta.
#include «Arduino.h»
class PlantHeight
{
private : long duration;
int deviceHeight;
byte trigPin, echoPin;
//Constructor to initialize HCS04 ultrasonic sensor pin and set the height read for the first time as a control or test value height
//or device height from the ground for comparisons in further readings
public: PlantHeight(byte t, byte e)
{
trigPin = t;
echoPin = e;
// Running a 20 round loop and get an average to make sure that I get a correct value,
// I found while testing the ultrasonic sensor that it gives 0 values for first 2 times(it might be due to no delay when I start the sensor)
delay(1000);
for (int i = 1; i <= 20; i++)
{
pinMode(trigPin, OUTPUT);
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
pinMode(echoPin, INPUT);
duration = pulseIn(echoPin, HIGH);
deviceHeight += microsecondsToCentimeters(duration); //height of device installed from ground
delay(1000);
}
deviceHeight = deviceHeight/20;
}
// Calculating plant relative height from the ground
public: int relativHeight()
{
int readings;
for (int i = 1; i <= 20; i++)
{
pinMode(trigPin, OUTPUT);
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
pinMode(echoPin, INPUT);
duration = pulseIn(echoPin, HIGH);
readings += microsecondsToCentimeters(duration);
delay(1000);
}
//the updated value of sensor reading is going to be sent
readings = readings/20;
return deviceHeight – readings ;
}
private: long microsecondsToCentimeters(long microseconds)
{
return microseconds / 29 / 2;
}
};
Otros sensores como el DHT11 se utilizan para medir la temperatura y la humedad, el LDR para detectar la intensidad de la luz y el sensor de humedad para detectar el porcentaje de agua en el suelo (algo muy fundamental en cada granja).
/*****************************************************************************************************************************************************************\
Smart Sensing with Arduino MKRFOX1200 and SigFox networks. Measuring environmental factors like humidity, temperature, gas concentration, light intensity, air
quality,noise levels. Test set determines the total number of times the readings are to be taken for calculating the mean value, since these cheap sensors are not
very accurate, this step might increase their efficiency. I used different functions to handle gas sensor and sound level sensor.
\*****************************************************************************************************************************************************************/
#include «Arduino.h»
class LightMoisture
{
private: byte _Moisture, _Ldr;
// Constructor to assign IO pins for individual environmental sensors
public : LightMoisture(byte moisturePin, byte lightPin)
{
_Moisture = moisturePin;
_Ldr = lightPin;
pinMode(_Moisture, INPUT);
pinMode(_Ldr, INPUT);
}
//Calculating light intensity % through ldr sensor
public : int lightIntensity()
{
// we will calculate the mean value of the 20 times sensor readings and calculate the percentage
return mean(_Ldr);
delay(2000);
}
//Calculating moisture %
public : int moisturePercentage()
{
// we will calculate the mean value of the 20 times sensor readings and calculate the percentage
return mean(_Moisture);
delay(2000);
}
//A function for finding average sensor readings
private : int mean(byte sensor)
{
int s = 0, m = 0;
for (byte i = 1; i <= 20; i++)
{
s += (analogRead(sensor));
}
m = (int) ((s / 20) / 1023) * 100; // converting the sensor mean value to %
if(m==100)
return 99;
else
return m;
}
};
Estoy usando el sensor de gas MQ2 para detectar humo y monóxido de carbono (puede usar algunos buenos sensores de detección de CO2, es más útil medir CO2 que CO para determinar la tasa de fotosíntesis, pedí uno pero no llegó a tiempo de todos modos, el trabajo es lo mismo para cualquier sensor que utilice). Dado que el sensor MQ2 no puede calcular directamente la concentración de gases en el aire, la hoja de datos proporciona un gráfico no lineal que hace que cualquier fórmula no esté definida para él. Hay otros sensores que dan lecturas precisas.
El tutorial de este link me ayudó mucho a saber cómo la fórmula [pow (10, (((log (rs_ro_ratio) -pcurve [1]) / pcurve [2]) + pcurve [0]))] me va a dar ppm. Dado que es un gráfico logarítmico, hallar la pendiente no es preciso ni fácil. Para encontrar la pendiente, primero tome 2 puntos del gráfico, encuentre la coordenada del eje y y la coordenada del eje x, ya que es un gráfico log-log, encuentre los valores logarítmicos respectivos de cada coordenada con base 10, luego sustituya en ( y2-y1) = m (x2-x1), donde «m» es pendiente, pero esto no va a ser correcto porque es una gráfica logarítmica. Hay muchos sensores precisos en el mercado, por lo que no necesitamos preocuparnos demasiado aquí porque cuando hagamos el producto final elegiremos el más confiable (es solo un prototipo).
#include «Arduino.h»
class GasConcentration
{
int MQ_PIN, //define which analog input channel you are going to use
RL_VALUE = 5; //define the load resistance on the board, in kilo ohms
float RO_CLEAN_AIR_FACTOR = 9.83; //RO_CLEAR_AIR_FACTOR=(Sensor resistance in clean air)/RO,
//which is derived from the chart in datasheet
/***********************Software Related Macros************************************/
int CALIBARAION_SAMPLE_TIMES = 50, //define how many samples you are going to take in the calibration phase
CALIBRATION_SAMPLE_INTERVAL = 500, //define the time interal(in milisecond) between each samples
READ_SAMPLE_INTERVAL = 50, //define how many samples you are going to take in normal operation
READ_SAMPLE_TIMES = 5; //define the time interal(in milisecond) between each samples in
//normal operation
/**********************Application Related Macros**********************************/
const int GAS_CO = 1;
const int GAS_SMOKE = 2;
/*****************************Globals***********************************************/
float MethaneCurve[3] = {2.3, 0.21, -0.47}; //two points are taken from the curve.
//with these two points, a line is formed which is «approximately equivalent»
//to the original curve.
//data format:{ x, y, slope}; point1: (lg200, 0.21), point2: (lg10000, -0.59)
float COCurve[3] = {2.3, 0.72, -0.34}; //two points are taken from the curve.
//with these two points, a line is formed which is «approximately equivalent»
//to the original curve.
//data format:{ x, y, slope}; point1: (lg200, 0.72), point2: (lg10000, 0.15)
float SmokeCurve[3] = {2.3, 0.53, -0.44}; //two points are taken from the curve.
//with these two points, a line is formed which is «approximately equivalent»
//to the original curve.
//data format:{ x, y, slope}; point1: (lg200, 0.53), point2: (lg10000, -0.22)
float Ro = 10; //Ro is initialized to 10 kilo ohms
public: GasConcentration(byte gasPin)
{
MQ_PIN = gasPin;
Ro = MQCalibration(MQ_PIN); //Calibrating the sensor. Please make sure the sensor is in clean air
delay(3000);
}
private : float MQCalibration(int mq_pin)
{
int i;
float val = 0;
for (i = 0; i < CALIBARAION_SAMPLE_TIMES; i++) { //take multiple samples
val += MQResistanceCalculation(analogRead(mq_pin));
delay(CALIBRATION_SAMPLE_INTERVAL);
}
val = val / CALIBARAION_SAMPLE_TIMES; //calculate the average value
val = val / RO_CLEAN_AIR_FACTOR; //divided by RO_CLEAN_AIR_FACTOR yields the Ro
return val; //according to the chart in the datasheet
}
private : float MQResistanceCalculation(int raw_adc)
{
return ( ((float)RL_VALUE * (1023 – raw_adc) / raw_adc));
}
float MQRead(int mq_pin)
{
int i;
float rs = 0;
for (i = 0; i < READ_SAMPLE_TIMES; i++) {
rs += MQResistanceCalculation(analogRead(mq_pin));
delay(READ_SAMPLE_INTERVAL);
}
rs = rs / READ_SAMPLE_TIMES;
return rs;
}
private : long MQGetGasPercentage(float rs_ro_ratio, int gas_id)
{
if ( gas_id == GAS_CO )
{
return MQGetPercentage(rs_ro_ratio, COCurve);
}
else if ( gas_id == GAS_SMOKE )
{
return MQGetPercentage(rs_ro_ratio, SmokeCurve);
}
return 0;
}
private : long MQGetPercentage(float rs_ro_ratio, float *pcurve)
{
return (pow(10, ( ((log(rs_ro_ratio) – pcurve[1]) / pcurve[2]) + pcurve[0])));
}
public : long COgasMeasure()
{
long iPPM_CO = 0;
iPPM_CO = MQGetGasPercentage(MQRead(MQ_PIN) / Ro, GAS_CO);
return iPPM_CO;
}
public : long SmokeMeasure()
{
long iPPM_Smoke = 0;
iPPM_Smoke = MQGetGasPercentage(MQRead(MQ_PIN) / Ro, GAS_SMOKE);
return iPPM_Smoke;
}
};
Por lo tanto, ahora puede tener un gráfico en el panel y puede visualizar cualquier combinación de factores que conducen al crecimiento de las plantas y experimentar con sus estas. Entonces te conviertes en el maestro de tus plantas. El sensor de gas también tomaría nota del fuego (humo) en el campo.
Control de la salud de los agricultores y la aldea
Con este dispositivo, el agricultor no solo puede registrar la salud de las plantas sino también mantener su propia salud, utilicé KY-039, un módulo contador de frecuencia cardíaca económico. Mientras jugaba con él, descubrí que no es tan preciso y los valores analógicos aumentan cuando colocamos el dedo sobre él. Es bastante efectivo para mi proyecto. Hice una interrupción en el código arduino para almacenar los datos de los latidos del corazón solo cuando se detecta un aumento en el valor analógico que indica que el usuario quiere verificar su latido. Posteriormente, estos datos se enviarían al panel de control para que el usuario los vea más adelante (todos los datos también se mostrarán en la pantalla OLED del dispositivo). Siempre que un agricultor no se sienta bien, puede utilizar esta función para comprobar si su pulso es normal o no.
#include «Arduino.h»
class PulseRate
{
public:
const byte rise_threshold = 4, samp_siz = 4;
byte _Sensor;
public : PulseRate(byte sensorPin)
{
_Sensor = sensorPin;
pinMode(_Sensor, INPUT);
}
public : int measurePulse()
{
int readingTime = 10000;
int startTime = millis();
float reads[samp_siz], sum;
long int now, ptr;
float last, reader, start;
float first, second, third, before, print_value;
bool rising;
int rise_count;
int n;
long int last_beat;
do
{
for (int i = 0; i < samp_siz; i++)
reads[i] = 0;
sum = 0;
ptr = 0;
while (1)
{
// calculate an average of the sensor
// during a 20 ms period (this will eliminate
// the 50 Hz noise caused by electric light
n = 0;
start = millis();
reader = 0.;
do
{
reader += analogRead (_Sensor);
n++;
now = millis();
}
while (now < start + 20);
reader /= n; // we got an average
// Add the newest measurement to an array
// and subtract the oldest measurement from the array
// to maintain a sum of last measurements
sum -= reads[ptr];
sum += reader;
reads[ptr] = reader;
last = sum / samp_siz;
// now last holds the average of the values in the array
// check for a rising curve (= a heart beat)
if (last > before)
{
rise_count++;
if (!rising && rise_count > rise_threshold)
{
// Ok, we have detected a rising curve, which implies a heartbeat.
// Record the time since last beat, keep track of the two previous
// times (first, second, third) to get a weighed average.
// The rising flag prevents us from detecting the same rise more than once.
rising = true;
first = millis() – last_beat;
last_beat = millis();
// Calculate the weighed average of heartbeat rate
// according to the three last beats
print_value = 60000. / (0.4 * first + 0.3 * second + 0.3 * third);
Serial.print(print_value);
Serial.print(‘\n’);
third = second;
second = first;
}
}
else
{
// Ok, the curve is falling
rising = false;
rise_count = 0;
}
before = last;
ptr++;
ptr %= samp_siz;
}
} while (millis() – startTime <= readingTime);
return print_value;
}
};
SigFy v2.0 (Versión 2.0)
Detección de determinados organismos beneficiosos y nocivos mediante análisis de sonido
Dado que la memoria y la memoria RAM de MKRFOX 1200 son limitadas, no podemos realizar técnicas complejas de análisis de sonido, los algoritmos raspberry pi y FFT (Fast Fourier Transformation) pueden hacer este trabajo de manera más eficiente, pero no tengo los módulos SigFox necesarios para raspberry pi. Sin embargo, el principio sigue siendo el mismo y, para fines de demostración, mi proyecto encaja perfectamente. Estoy usando la biblioteca FreqMeasure.h, no funciona con placas MKR si quiero que funcione. Necesito crear métodos de temporizador y contador para interrupciones y temporizadores integrados (solo tengo 15 años, no lo he aprendido mucho sobre el microcontrolador, publiqué ayuda en el foro de arduino pero no obtuve ninguna respuesta), pero lo haré funcionar de todos modos. https://github.com/PaulStoffregen/FreqMeasure. Entonces, para que funcione, usaré Arduino UNO para calcular la frecuencia de audio del sensor de sonido (estoy usando un módulo de sensor de sonido de descenso para detectar frecuencias, sin embargo, puede comprar un módulo analizador de audio como MAX4466 para detectar con mayor precisión, puede detectar algunas frecuencias muy prominentes muy fácilmente y con menos códigos) y luego, usando la comunicación en serie entre los dos (Arduino UNO y MKRFOX 1200), voy a recibir la respuesta como qué objeto hizo ese sonido junto con la frecuencia recibida. Así que mi trabajo está hecho, Arduino UNO actuará como dispositivo esclavo y MKRFox como dispositivo maestro. Si alguien me puede ayudar a hacer uso de la biblioteca directamente en lugar de usar la comunicación en serie, por favor envíeme un mensaje o publique aquí. Aquí está el código Arduino UNO para detectar la frecuencia de audio y enviarla a MKFOX1200 mediante comunicación en serie.
#include <FreqMeasure.h>//https://github.com/PaulStoffregen/FreqMeasure
void setup() {
Serial.begin(57600);
Serial.println(«hi»);
FreqMeasure.begin(); //Measures on pin 8 by default
pinMode(LED_BUILTIN, OUTPUT);
}
double sum = 0;
int count = 0;
bool state = true;
float frequency;
int continuity = 0;
int id = 0;
void loop() {
if (FreqMeasure.available()) {
// average several reading together
sum = sum + FreqMeasure.read();
count = count + 1;
if (count > 30) {
frequency = FreqMeasure.countToFrequency(sum / count);
//Serial.println(frequency); we were using this during the testing phase
sum = 0;
count = 0;
}
}
if (frequency > 6800 && frequency < 7200)
{
id = 1;
continuity++;
// Serial.print(«Continuity -> «);
// Serial.println(continuity);
frequency = 0;
}
if (frequency > 145 && frequency < 375)
{
id = 2;
continuity++;
//Serial.print(«Continuity -> «);
//Serial.println(continuity);
frequency = 0;
}
if (frequency > 800 && frequency < 1200)
{
id = 3;
continuity++;
//Serial.print(«Continuity -> «);
//Serial.println(continuity);
frequency = 0;
}
if (frequency > 5000 && frequency < 6500)
{
id = 4;
continuity++;
//Serial.print(«Continuity -> «);
//Serial.println(continuity);
frequency = 0;
}
if (continuity >= 3)
{
continuity = 0;
switch (id)
{
case 1: Serial.print(id); // noisy cricket
break;
case 2: Serial.print(id); // mosquito
break;
case 3: Serial.print(id); // honeybee
break;
case 4: Serial.print(id); // chain saw
break;
default: Serial.print(0);
}
id=0;
delay(2000);
}
digitalWrite(LED_BUILTIN, state);
}
En MKRFOX1200 usaremos la comunicación en serie para recibir los mensajes anteriores y enviarlos a la nube SigFox.
#include <ArduinoLowPower.h>
#include <SigFox.h>
int FirePin = 5;
int firevalue;
volatile int fireStatus;
String str; // String to store message
struct SigFoxData
{
int fireData;
int serialData;
};
SigFoxData data;
void setup()
{
Serial.begin(57600);
while (!Serial) {}
if (!SigFox.begin()) {
// Something is really wrong, try rebooting
// Reboot is useful if we are powering the board using an unreliable power source
// (eg. solar panels or other energy harvesting methods)
reboot();
}
LowPower.attachInterruptWakeup(FirePin, fireDetect, RISING);
//Send module to standby until we need to send a message
SigFox.end();
}
void fireDetect()
{
fireStatus = 1;
}
void loop()
{
if (fireStatus == 1)
{
data.fireData = fireStatus;
fireStatus = 0;
}
else
{
data.fireData = 0;
}
int x;
while (Serial.available() > 0)
{
x = Serial.read();
data.serialData = x;
delay(2000);
}
parseData();
sendSigfoxData();
LowPower.sleep(10 * 60 * 1000); // going to sleep for 10 minutes
}
void parseData()
{
str = «SA» + 0 + data.serialData + 0 + data.fireData; // SA refers to sound analysis, we will use these keys to identify the type of message in thethings.io dashboard
}
void sendSigfoxData()
{
// Start the module
SigFox.begin();
// Wait at least 30mS after first configuration (100mS before)
delay(100);
// Clears all pending interrupts
SigFox.status();
delay(1);
SigFox.beginPacket();
SigFox.print(str);
int ret = SigFox.endPacket(); // send buffer to SIGFOX network
if (ret > 0)
{
Serial.println(«No transmission»);
}
else
{
Serial.println(«Transmission ok»);
}
Serial.println(SigFox.status(SIGFOX));
Serial.println(SigFox.status(ATMEL));
SigFox.end();
}
void reboot()
{
NVIC_SystemReset();
while (1);
}
Configuración de hardware
Para el SigFy v1.0 utilicé la caja de un reloj despertador digital. Eche un vistazo al cableado, estamos alimentando los sensores externamente.
SigFy v2.0
La versión dos solo consta de sensor de sonido y sensor de fuego
Configuración de SigFox
Yo vivo en la India y no tenemos una estación base SigFox aquí, así que voy a utilizar un dispositivo de seguridad para el uso de DEG devoluciones de llamada en mi proyecto. Descargue el emulador de red Sigfox desde aquí https://build.sigfox.com/sdr-dongle también lea los documentos detenidamente.
Configuración para dongle SDR
Paso 1: conecte el hardware y configure las devoluciones de llamada.
Paso 2: Configurar thethings.io
Si ha configurado bien su dispositivo, entonces debería mostrar una flecha verde hacia arriba para tener éxito.
Vaya al código de la nube en el menú de thethings.io . Esta es la función que convierte nuestros datos de HEX a ASCII y luego configura los campos de valor para mostrarlos en el gráfico o tablero.
function hex_to_ascii(str1)
{
var hex = str1.toString();
var str = »;
for (var n = 0; n < hex.length; n += 2) {
str += String.fromCharCode(parseInt(hex.substr(n, 2), 16));
}
return str;
}
Y ahora vamos a hacer que parse funcione en thethings.io para reconocer los bytes de datos:
Estas son las primeras lecturas del sensor, utilicé el identificador «SD» para hacerme entender que solo se trata de datos de áreas circundantes.
if(hex_to_ascii(params.data.substring(0,4)) == «SD»)
{
//Replace with your own payload parse
var result = [
{
«key»:»identifier»,
«value»:hex_to_ascii(params.data.substring(0,4))
},
{
«key»: «temperature»,
«value»: hex_to_ascii(params.data.substring(4,8))
},
{
«key»: «humidity»,
«value»: hex_to_ascii(params.data.substring(8,12))
},
{
«key»: «light»,
«value»: hex_to_ascii(params.data.substring(12,16))
},
{
«key» : «dewPoint»,
«value» : hex_to_ascii(params.data.substring(16,20))
},
{
«key» : «heatIndex»,
«value» : hex_to_ascii(params.data.substring(20,24))
}
]
callback(null, result)
}
Después de eso, estoy leyendo los datos de la planta junto con los latidos del corazón, se usa «PD» para diferenciar esta función de otros datos.
if(hex_to_ascii(params.data.substring(0,4)) == «PD»)
{
//Replace with your own payload parse
var result = [
{
«key»:»identifier»,
«value»:hex_to_ascii(params.data.substring(0,4))
},
{
«key»: «moisture»,
«value»: hex_to_ascii(params.data.substring(4,8))
},
{
«key»: «plantHeight»,
«value»: hex_to_ascii(params.data.substring(8,12))
},
{
«key»: «heartBeat»,
«value»: hex_to_ascii(params.data.substring(12,16))
},
{
«key» : «carbonDioxide»,
«value» : hex_to_ascii(params.data.substring(16,20))
},
{
«key» : «smoke»,
«value» : hex_to_ascii(params.data.substring(20,24))
}
]
callback(null, result)
}
Este es el último dato en el que vamos a buscar datos y detectar si es sonido de mosquito o de qué frecuencia también verificamos el estado del fuego.
if(hex_to_ascii(params.data.substring(0,4)) == «SA»)
{
//Replace with your own payload parse
var result = [
{
«key»:»identifier»,
«value»:hex_to_ascii(params.data.substring(0,4))
},
{
«key»: «object»,
«value»: object(hex_to_ascii(params.data.substring(6,8)) )
},
{
«key»: «audiofrequency»,
«value»: frequency(hex_to_ascii(params.data.substring(6,8)) )
},
{
«key»: «fireStatus»,
«value»: fire(hex_to_ascii(params.data.substring(10,12)))
}
]
callback(null, result)
}
function object(str)
{
var str1=str;
if(str1 == «1»)
return «cricket»
if(str1==»2″)
return «mosquito»
if(str1==»3″)
return «honeybees»
if(str1==»4″)
return «chainsaw»
}
function frequency(str)
{
// just calculating average frequency
var str1=str;
if(str1 == «1»)
return ((6800+7200)/2)
if(str1==»2″)
return ((145+375)/2)
if(str1==»3″)
return ((800+1200)/2)
if(str1==»4″)
return ((5000+6500)/2)
}
function fire(str)
{
var str1=str
if(str1==»1″)
return «Fire»
if(str1==»0″)
return «Normal»
}
El código final se adjunta al final. Si pudo seguirme, debería obtener su panel de control como este en la configuración.
SigFy v1.0 funciona a la perfección. Como solo tenía un MKRFOX, tuve que desmantelar la v1.0 para hacer la v2.0. Entonces, con esto, hemos completado el proyecto, podemos trabajar más en esto, ya que estaba enfrentando algunos problemas mientras usaba el dongle SDR, me quedé sin tiempo para agregar más funciones como el manejo de datos y algoritmos de ML en thethings.io y notificaciones, sin embargo Lo agregaré muy pronto, pero creo que pude demostrar claramente cómo podemos usar pequeños sensores para recopilar datos tan importantes. También es un impulso para Sigfox agregar India también a su lista para que también podamos disfrutar de una herramienta de IoT tan genial.
TRABAJO HECHO
Disfrute de este proyecto y felicítese por haber creado su propio kit ambiental flexible para su vecindario (pista: use el kit SigFy v2.0 para monitorear la reproducción de mosquitos en su localidad y el kit SigFy v1.0 para su jardín).
Excelente trabajo, muchas gracias.