Lora Smart Agriculture & Remote Monitoring System

7.1. Archivo Main.ino

#include 
#include "RH_RF95.h"

#include "I2C_AHT10.h"
#include 
AHT10 humedadSensor;

int sensorPin = A2;    Seleccione el pin de entrada para el potenciómetro
int sensorValue = 0;  variable para almacenar el valor procedente del sensor
int sensorPowerCtrlPin = 5;

sensor voidPowerOn(vacío)
{
  digitalWrite(sensorPowerCtrlPin, HIGH);//Encendido del sensor
}
void sensorPowerOff(void)
{
  digitalWrite(sensorPowerCtrlPin, LOW);//Encendido del sensor
}

#define RFM95_CS 10
#define RFM95_RST 4
#define RFM95_INT 2

Cambie a 434.0 u otra frecuencia, ¡debe coincidir con el freq de RX!
#define RF95_FREQ 433.0

Instancia única del controlador de radio
RH_RF95 rf95(RFM95_CS, RFM95_INT);

void setup()
{

pinMode(RFM95_RST, SALIDA);
  digitalWrite(RFM95_RST, LOW);
  retraso(100);
  digitalWrite(RFM95_RST, ALTA);

pinMode(sensorPowerCtrlPin, OUTPUT);
  digitalWrite(sensorPowerCtrlPin, LOW);//Encendido del sensor
  sensorPowerOn();
  pinMode(sensorPin, INPUT);

mientras que (! Serie);
  Serial.begin(115200);
  retraso(100);

Wire.begin(); Únete al autobús I2C
  Compruebe si el AHT10 reconocerá
  if (humiditySensor.begin() == false)
  {
    Serial.println("AHT10 no detectado. Por favor, compruebe el cableado. Congelación.");
    mientras que (1);
  }
  más
    Serial.println("AHT10 reconocido.");

Serial.println("Marduino LoRa TX Test!");

Restablecimiento manual
  digitalWrite(RFM95_RST, LOW);
  retraso(10);
  digitalWrite(RFM95_RST, ALTA);
  retraso(10);

while(!rf95.init()) {
    Serial.println("LoRa radio init failed");
    mientras que (1);
  }
  Serial.println("LoRa radio init OK!");

rf95.setModemConfig(Bw125Cr48Sf4096);

Los valores predeterminados después de init son 434.0MHz, modulación GFSK_Rb250Fd250, +13dbM
  if (!rf95.setFrequency(RF95_FREQ)) {
    Serial.println("setFrequency failed");
    mientras que (1);
  }
  Serial.print("Establecer frecuencia en: ");
  Serial.println(RF95_FREQ);

Los valores predeterminados después de la entrada son 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/símbolo, CRC activado

La potencia predeterminada del transmisor es de 13dBm, utilizando PA_BOOST.
  Si está utilizando módulos RFM95/96/97/98 que utilizan el pin del transmisor PA_BOOST, entonces
  puede ajustar las potencias del transmisor de 5 a 23 dBm:
  rf95.setTxPower(23, false);

dht.begin();
}

int16_t packetnum = 0;  contador de paquetes, incrementamos por xmission
temperatura de flotación = 0.0;//
humedad flotante = 0.0;

void loop()
{

¡La lectura de la temperatura o la humedad tarda unos 250 milisegundos!
  Las lecturas del sensor también pueden ser de hasta 2 segundos "antiguas" (es un sensor muy lento)
  humedad flotante = 6.18;//dht.readHumidity();
  Leer la temperatura como Celsius (valor predeterminado)

sensorPowerOn();//
  retraso(100);
  sensorValue = analogRead(sensorPin);
  retraso(200);

if (humiditySensor.available() == true)
  {
    Obtenga el nuevo valor de temperatura y humedad
    temperatura = humedadSensor.getTemperature();
    humedad = humedadSensor.getHumidity();

Imprimir los resultados
    Serial.print("Temperatura: ");
    Serial.print (temperatura, 2);
    Serial.print(" C\t");
    Serial.print("Humedad: ");
    Serial.print (humedad, 2);
    Serial.println("% HR");

}
    Compruebe si alguna lectura falló y salga temprano (para intentarlo de nuevo).
    if (isnan(humedad) || isnan(temperatura)) {
    Serial.println(F("¡Error al leer desde el sensor AHT!"));
    devolución;
  }

retraso(100);
  sensorPowerOff();

Serial.print(F("ADC de humedad : "));
  Serial.println(sensorValue);

Serial.print(F("Humedad: "));
  Serial.print (humedad);
  Serial.print(F("% Temperatura: "));
  Serial.print (temperatura);
  Serial.println("La humedad es " + (cadena)humedad);
  Serial.println("La temperatura es " + (cadena)temperatura);

String message = "#"+(String)packetnum+" Humedad:"+(String)humidity+"% Temperature:"+(String)temperature+"C"+" ADC:"+(String)sensorValue;
  Serial.println(mensaje);
  packetnum++;
  Serial.println("Transmitir: Enviar a rf95_server");

Enviar un mensaje a rf95_server

uint8_t radioPacket[message.length()+1];
  message.toCharArray(radioPacket, message.length()+1);

radioPacket[message.length()+1]= '\0';

Serial.println("Enviando..."); retraso(10);
  rf95.send((uint8_t *)radioPacket, message.length()+1);
  Serial.println("Esperando a que se complete el paquete..."); retraso(10);
  rf95.waitPacketSent();
  Ahora espera una respuesta
  uint8_t buf[RH_RF95_MAX_MESSAGE_LEN];
  uint8_t len = sizeof(buf);

Serial.println("Esperando respuesta..."); retraso(10);
  if(rf95.waitAvailableTimeout(8000))
  {
    Debería ser un mensaje de respuesta para nosotros ahora
    if (rf95.recv(buf, &len))
  {
     Serial.print("Got reply: ");
     Serial.println((char*)buf);
     Serial.print("RSSI: ");
     Serial.println(rf95.lastRssi(), DEC);
    }
    más
    {
     Serial.println("Error de recepción");
    }
  }
  más
  {
    Serial.println("Sin respuesta, ¿hay un oyente alrededor?");
  }
  retraso(1000);
}

7.2. Archivo I2C_AHT10.cpp

#include "I2C_AHT10.h"

/*--------------------------- Estado del dispositivo ------------------------------*/
bool AHT10::begin(TwoWire &wirePort)
{
    _i2cPort = &wirePort; //Toma el puerto en el que el usuario desea comunicarse

_deviceAddress = AHT10_DEFAULT_ADDRESS; Esperábamos que el AHT10 admitiera dos direcciones, pero no parece

if (isConnected() == false)
        devolver false;

Espere 40 ms después del encendido antes de leer la temperatura o la humedad. Hoja de datos pg 8
    retraso(40);

Compruebe si la broca calibrada está configurada. Si no, inicie el sensor.
    if (isCalibrated() == false)
    {
        Enviar 0xBE0800
        initialize();

Activar inmediatamente una medición. Enviar 0xAC3300
        triggerMeasurement();

retraso(75); Espere a que se complete la medición

uint8_t contador = 0;
        while (isBusy())
        {
            retraso(1);
            if (contador++ > 100)
                retorno (falso); Darse por vencido después de 100 ms
        }

Esta secuencia de calibración no está completamente probada. No está claro cómo y cuándo se borra el bit cal
        Esto parece funcionar, pero no es fácil de probar
        if (isCalibrated() == false)
        {
            retorno (falso);
        }
    }

Compruebe que se ha configurado el bit cal
    if (isCalibrated() == false)
        devolver false;

Marcar todos los datos como nuevos (no leídos antes)
    sensorQueried.temperature = true;
    sensorQueried.moisture = true;

devolver verdadero;
}

Hacer ping a la dirección I2C del AHT10
Si obtenemos una respuesta, nos estamos comunicando correctamente con el AHT10
bool AHT10::isConnected()
{
    _i2cPort->beginTransmission(_deviceAddress);
    if (_i2cPort->endTransmission() == 0)
        devolver verdadero;

Si IC no respondió, déle 20 ms más para el inicio de encendido
    Hoja de datos pg 7
    retraso(20);

_i2cPort->beginTransmission(_deviceAddress);
    if (_i2cPort->endTransmission() == 0)
        devolver verdadero;

devolver false;
}

/*------------------------ Ayudantes de medición ---------------------------*/

uint8_t AHT10::getStatus()
{
    _i2cPort->requestFrom(_deviceAddress, (uint8_t)1);
    if (_i2cPort->available())
        return (_i2cPort->read());
    retorno (0);
}

Devuelve el estado del bit cal en el byte de estado.
bool AHT10::isCalibrated()
{
    return (getStatus() & (1 beginTransmission(_deviceAddress);
    _i2cPort->write(sfe_aht10_reg_initialize);
    _i2cPort->write(0x80);
    _i2cPort->write(0x00);
    if (_i2cPort->endTransmission() == 0)
        devolver verdadero;
    devolver false;
}

bool AHT10::triggerMeasurement()
{
    _i2cPort->beginTransmission(_deviceAddress);
    _i2cPort->write(sfe_aht10_reg_measure);
    _i2cPort->write(0x33);
    _i2cPort->write(0x00);
    if (_i2cPort->endTransmission() == 0)
        devolver verdadero;
    devolver false;
}

Carga el
void AHT10::readData()
{
    Borrar datos anteriores
    sensorData.temperature = 0;
    sensorData.humedad = 0;

if (_i2cPort->requestFrom(_deviceAddress, (uint8_t)6) > 0)
    {
        uint8_t estado = _i2cPort->read();

uint32_t entrante = 0;
        entrante |= (uint32_t)_i2cPort->read() read() read(); 

entrante |= midByte;
        sensorData.moisture = >> entrante 4;

sensorData.temperature = (uint32_t)midByte read() read()  20
        sensorData.temperature = sensorData.temperature & ~(0xFFF00000);

Marcar datos como nuevos
        sensorQueried.temperature = false;
        sensorQueried.moisture = false;
    }
}

Activa una medición si no se ha iniciado previamente y, a continuación, devuelve false
Si se ha iniciado la medición, compruebe si está completa.
Si no está completado, devuelve false
Si está completa, readData(), marque la medición como no iniciada, devuelva true
bool AHT10::available()
{
    if (measurementStarted == false)
    {
        triggerMeasurement();
        measurementStarted = true;
        retorno (falso);
    }

if (isBusy() == true)
    {
        retorno (falso);
    }

readData();
    measurementStarted = false;
    retorno (verdadero);
}

bool AHT10::softReset()
{
    _i2cPort->beginTransmission(_deviceAddress);
    _i2cPort->write(sfe_aht10_reg_reset);
    if (_i2cPort->endTransmission() == 0)
        devolver verdadero;
    devolver false;
}

/*------------------------- Realizar mediciones ----------------------------*/

float AHT10::getTemperature()
{
    if (sensorQueried.temperature == true)
    {
        Tenemos datos antiguos, así que activa nuevas mediciones
        triggerMeasurement();

retraso(75); Espere a que se complete la medición

uint8_t contador = 0;
        while (isBusy())
        {
            retraso(1);
            if (contador++ > 100)
                retorno (falso); Darse por vencido después de 100 ms
        }

readData();
    }

De la hoja de datos pg 8
    float tempCelsius = ((float)sensorData.temperature / 1048576) * 200 - 50;

Marcar datos como antiguos
    sensorQueried.temperature = true;

volver tempCelsius;
}

float AHT10::getHumidity()
{
    if (sensorQueried.moisture == true)
    {
        Tenemos datos antiguos, así que activa nuevas mediciones
        triggerMeasurement();

retraso(75); Espere a que se complete la medición

uint8_t contador = 0;
        while (isBusy())
        {
            retraso(1);
            if (contador++ > 100)
                retorno (falso); Darse por vencido después de 100 ms
        }

readData();
    }

De la hoja de datos pg 8
    float relHumidity = ((float)sensorData.moisture / 1048576) * 100;

Marcar datos como antiguos
    sensorQueried.moisture = true;

retorno relHumedad;
}

7.3. Archivo I2C_AHT10.h

#ifndef __I2C_AHT10_H__
#define __I2C_AHT10_H__

#include 
#include 

#define AHT10_DEFAULT_ADDRESS 0x38

Registros de enumeración
{
    sfe_aht10_reg_reset = 0xBA,
    sfe_aht10_reg_initialize = 0xBE,
    sfe_aht10_reg_measure = 0xAC,
};

clase AHT10
{
privado:
    TwoWire *_i2cPort; La conexión genérica al hardware I2C elegido por el usuario
    uint8_t _deviceAddress;
    bool measurementStarted = false;

Estructura
    {
        uint32_t humedad;
        uint32_t temperatura;
    } sensorData;

Estructura
    {
        uint8_t temperatura : 1;
        uint8_t humedad : 1;
    } sensorQueried;

público:
    Estado del dispositivo
    bool begin(TwoWire &wirePort = Wire); Establece la dirección del dispositivo y abre el bus I2C
    bool isConnected();                   Comprueba si el AHT10 está conectado al bus I2C
    bool disponible();                     Devuelve true si hay nuevos datos disponibles.

Funciones auxiliares de medición
    uint8_t getStatus();       Devuelve el byte de estado.
    bool isCalibrated();       Devuelve true si se establece el bit cal, false de lo contrario
    bool isBusy();           Devuelve true si se establece el bit ocupado, false de lo contrario
    bool initialize();        Inicializar para tomar medidas
    bool triggerMeasurement();  Activar el AHT10 para tomar una medición
    void readData();         Leer y analizar los 6 bytes de datos en humedad y temperatura sin procesar
    bool softReset();        Reinicie el sistema del sensor sin apagar y encender

Realizar mediciones
    float getTemperature(); Pasa por la secuencia de medición y devuelve la temperatura en grados centígrados
    float getHumidity();    Pasa por la secuencia de medición y devuelve la humedad en % HR
};
#endif

8. Código del receptor

#include 
#include 
#define RFM95_CS 10
#define RFM95_RST 9
#define RFM95_INT 2
Cambie a 434.0 u otra frecuencia, ¡debe coincidir con el freq de RX!
#define RF95_FREQ 433.0
Instancia única del controlador de radio
RH_RF95 rf95(RFM95_CS, RFM95_INT);

int count=0;

void setup()
{
  pinMode(RFM95_RST, SALIDA);
  digitalWrite(RFM95_RST, ALTA);
  mientras que (! Serie);
  Serial.begin(115200);
  retraso(100);
  Serial.println("Arduino LoRa RX Test!");

Restablecimiento manual
  digitalWrite(RFM95_RST, LOW);
  retraso(10);
  digitalWrite(RFM95_RST, ALTA);
  retraso(10);
  while (!rf95.init()) {
    Serial.println("LoRa radio init failed");
    mientras que (1);
  }
  Serial.println("LoRa radio init OK!");
  Los valores predeterminados después de init son 434.0MHz, modulación GFSK_Rb250Fd250, +13dbM
  if (!rf95.setFrequency(RF95_FREQ)) {
    Serial.println("setFrequency failed");
    mientras que (1);
  }
  Serial.print("Establecer frecuencia en: "); Serial.println(RF95_FREQ);
  Los valores predeterminados después de la entrada son 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/símbolo, CRC activado
  La potencia predeterminada del transmisor es de 13dBm, utilizando PA_BOOST.
  Si está utilizando módulos RFM95/96/97/98 que utilizan el pin del transmisor PA_BOOST, entonces
  puede ajustar las potencias del transmisor de 5 a 23 dBm:
  rf95.setTxPower(23, false);
}
void loop()
{
  if (rf95.available())
  {
    Debería ser un mensaje para nosotros ahora
    uint8_t buf[RH_RF95_MAX_MESSAGE_LEN];
    uint8_t len = sizeof(buf);

if (rf95.recv(buf, &len))
    {
      contar++;
      RH_RF95::p rintBuffer("Received: ", buf, len);
      Serial.print("Got: ");
      Serial.println((char*)buf);
      Serial.print("RSSI: ");
      Serial.println(rf95.lastRssi(), DEC);

Enviar una respuesta
      uint8_t data[] = "Y hola de vuelta a ti";
      rf95.send(data, sizeof(data));
      rf95.waitPacketSent();
      Serial.println("Enviado una respuesta");
    }
    más
    {
      Serial.println("Error de recepción");
    }
  }
}

9. IoT LoRa basado en agricultura inteligente y sistema de monitoreo remoto

Veamos ahora una demostración simple de la agricultura inteligente basada en LoRa. Ahora puede abrir el monitor serie tanto para el transmisor como para el receptor. El transmisor y el receptor Lora comenzarán y se comunicarán entre sí.
 

El extremo del transmisor leerá los datos de humedad del suelo en ADC que se pueden convertir a un valor porcentual (Consulte este artículo...). Del mismo modo, elAHT10 recopilará datos de humedad y temperatura del aire. Los datos se transmiten a la puerta de enlace.

Los datos de la puerta de enlace se pueden observar en el monitor serie.