Buenas con tod@s.
Tengo un problema, estoy haciendo una red de sensores con xbee donde tengo 1 arduino con el shield y el xbee el cual esta como coordinador, y los otros dos xbee de la misma manera; con el xbee y su shield, pero en esos escalvos estan conectados sensores de humedad. Ahora ya me madnan los datos de los esclavos al coordinador pero no sé como identificar cual esclavo es el que me está madnando la información.
adjunto los códigos.
Cabe recalcar que estoy trabajndo con 3 arduinos UNO, 3 xbee shield y 3 xbee series 2.
Adjunto una imagen de como esta la conexión
//COORDINADOR//
byte recepcion=0; // almacena el valor enviado desde el emisor
int porcentaje; // utilizada para pasar el valor a grados
void setup(){
Serial.begin(9600);
}
void loop () {
if (Serial.available() > 0) { // si hay algun dato entrado por el serial empezamos
recepcion=Serial.read(); // se lee el dato se almacena
porcentaje=recepcion; // Volcado del dato recibido del emsior
if (porcentaje >= 50){
Serial.println("MITAD DEL PORCENTAJE: ");
}
// Imprime el valor que recibe
Serial.println(recepcion);
delay(1000);
}
}
AHORA LOS ESCALVOS
esclavo 1
#define AOUT 0 // Pin analógico "A0" para conectar la salida del sensor de humedad capacitivo
const int Valor_Sensor_Aire = 590; // Valor calculado con el programa de calibración con el sensor al aire
const int Valor_Sensor_Agua = 265; // Valor calculado con el programa de calibración con el sensor sumergido en agua
int valor_sensor = 0; // Variable que almacena el valor de salida del sensor de humedad capacitivo
int porcentaje = 0; // Variable que almacena el porcentaje de humedad relativa del terreno
void setup()
{
Serial.begin(9600); // Comienzo de la comunicación con el monitor serie del IDE de Arduino
}
void loop()
{
// Leemos el valor de la salida analógica del sensor capacitivo, conectada al pin analógico "A0"
valor_sensor = analogRead(AOUT);
// Se calcula el porcentaje de humedad relativa teniendo en cuenta los dos límites
porcentaje = map(valor_sensor, Valor_Sensor_Agua, Valor_Sensor_Aire, 100, 0);
if(porcentaje < 0) porcentaje = 0; // Evita porcentajes negativos en la medida del sensor
if(porcentaje > 100) porcentaje = 100; // Evita porcentajes negativos en la medida del sensor
//Serial.print(porcentaje);
Serial.write(byte (porcentaje));
delay(1000); // Retardo de un segundo entre lecturas del sensor de humedad capacitivo
}
esclavo 2: le puse lo mismo que el esclavo 1
#define AOUT 0 // Pin analógico "A0" para conectar la salida del sensor de humedad capacitivo
const int Valor_Sensor_Aire = 590; // Valor calculado con el programa de calibración con el sensor al aire
const int Valor_Sensor_Agua = 265; // Valor calculado con el programa de calibración con el sensor sumergido en agua
int valor_sensor = 0; // Variable que almacena el valor de salida del sensor de humedad capacitivo
int porcentaje = 0; // Variable que almacena el porcentaje de humedad relativa del terreno
void setup()
{
Serial.begin(9600); // Comienzo de la comunicación con el monitor serie del IDE de Arduino
}
void loop()
{
// Leemos el valor de la salida analógica del sensor capacitivo, conectada al pin analógico "A0"
valor_sensor = analogRead(AOUT);
// Se calcula el porcentaje de humedad relativa teniendo en cuenta los dos límites
porcentaje = map(valor_sensor, Valor_Sensor_Agua, Valor_Sensor_Aire, 100, 0);
if(porcentaje < 0) porcentaje = 0; // Evita porcentajes negativos en la medida del sensor
if(porcentaje > 100) porcentaje = 100; // Evita porcentajes negativos en la medida del sensor
//Serial.print(porcentaje);
Serial.write(byte (porcentaje));
delay(1000); // Retardo de un segundo entre lecturas del sensor de humedad capacitivo
}
if (Serial.available() > 1) { // si hay algun dato entrado por el serial empezamos
recepcion=Serial.read(); // se lee el dato
nro_esclavo = recepcion;
recepcion=Serial.read(); // se lee el dato se almacena
porcentaje=recepcion;
// lo que sigue
Envia siempre un Id seguido del dato correspondiente de un modo que tu entiendas.
Imaginemos 01dato 02dato 03dato
Luego el coordinador decodifica la información. Dira los primeros 2 bytes corresponden a ID y los demas al dato.
pfta bro, tu respuesta me ayudo socio, con eso ya tengo mi red de sensores, bueno ahora me toca importar a la nube esos datos, lo desarrollaré en estos días y espero avanzarlo.
Muchas gracias
Hola nuevamente, tengo un problema con mi red de sensores, lo que pasa es que en el coordinador ya tengo los datos de humedad obtenida de los 2 nodos o esclavos, y también ya identifica cual nodo es el que envía la información sin embargo ahora quiero utilizar el valor de cada nodo para activar y desactivar dos salidas.
Sin embargo ya, le he intentado pero no me funciona.
Adjunto el código:
//COORDINADOR//
char digitos[6];
int cont;
int porcentaje; // utilizada para pasar el valor a grados
const byte MOTOR = 2; //Salida para activar el motor
const byte VALVULA = 3; //Salida para activar la válvula
const byte STOP_FORZADO = 4; //Boton para forzar el STOP del sistema
void setup(){
pinMode(MOTOR, OUTPUT);
pinMode(VALVULA, OUTPUT);
pinMode(STOP_FORZADO, INPUT);
digitalWrite(MOTOR, HIGH);
digitalWrite(VALVULA, HIGH);
Serial.begin(9600);
}
void nodo_1(){
if(digitos[0]=='A'){ //Condición para identificar el caracter "A", para identificar el NODO 1
Serial.print("Nodo 1 HUMEDAD: ");
for(cont=1; cont<6; cont++){ //El contador para llegar a la sexta posicón
if(digitos[cont]!='B'){ //Condición para imprimir el valor de la humedad dada por el sensor del NODO 1
Serial.print(digitos[cont]); //Imprime
}
else{
break;
}
}
Serial.println("%"); //Imprime el simbolo del procentaje una vez que digitos[cont] == 'B'
}
}
void nodo_2(){
if(digitos[0]=='X'){
Serial.print("Nodo 2 HUMEDAD: ");
for(cont=1; cont<6; cont++){
if(digitos[cont]!='Y'){
Serial.print(digitos[cont]);
}
else{
break;
}
}
Serial.println("%");
}
}
void loop () {
while(Serial.available()> 0 ){
for(cont=0; cont<6; cont++){
digitos[cont]= Serial.read();
}
nodo_1();
nodo_2();
}
delay(100);
}
NODO 1
#define AOUT 0 // Pin analógico "A0" para conectar la salida del sensor de humedad capacitivo
const int Valor_Sensor_Aire = 590; // Valor calculado con el programa de calibración con el sensor al aire
const int Valor_Sensor_Agua = 265; // Valor calculado con el programa de calibración con el sensor sumergido en agua
int valor_sensor = 0; // Variable que almacena el valor de salida del sensor de humedad capacitivo
int porcentaje = 0; // Variable que almacena el porcentaje de humedad relativa del terreno
int nro_esclavo = 2;
void setup()
{
Serial.begin(9600); // Comienzo de la comunicación con el monitor serie del IDE de Arduino
}
void loop()
{
valor_sensor = analogRead(AOUT);
porcentaje = map(valor_sensor, Valor_Sensor_Agua, Valor_Sensor_Aire, 100, 0);
if(porcentaje < 0) porcentaje = 0;
if(porcentaje > 100) porcentaje = 100;
Serial.print('A');
Serial.print(porcentaje);
Serial.print('B');
delay(1000); // Retardo de un segundo entre lecturas del sensor de humedad capacitivo
}
NODO 2
#define AOUT 0 // Pin analógico "A0" para conectar la salida del sensor de humedad capacitivo
const int Valor_Sensor_Aire = 590; // Valor calculado con el programa de calibración con el sensor al aire
const int Valor_Sensor_Agua = 265; // Valor calculado con el programa de calibración con el sensor sumergido en agua
int valor_sensor = 0; // Variable que almacena el valor de salida del sensor de humedad capacitivo
int porcentaje = 0; // Variable que almacena el porcentaje de humedad relativa del terreno
int nro_esclavo = 2;
void setup()
{
Serial.begin(9600); // Comienzo de la comunicación con el monitor serie del IDE de Arduino
}
void loop()
{
valor_sensor = analogRead(AOUT);
porcentaje = map(valor_sensor, Valor_Sensor_Agua, Valor_Sensor_Aire, 100, 0);
if(porcentaje < 0) porcentaje = 0;
if(porcentaje > 100) porcentaje = 100;
Serial.print('X');
Serial.print(porcentaje);
Serial.print('Y');
delay(1000); // Retardo de un segundo entre lecturas del sensor de humedad capacitivo
}
Quiero trabajar con los valores obtenidos de cada nodo, en el coordinador para activar y desactivar las salidas.
#include <stdlib.h> /* atoi */
char digitos[6];
int cont;
int porcentaje; // utilizada para pasar el valor a grados
int humedad;
const byte MOTOR = 2; // Salida para activar el motor
const byte VALVULA = 3; // Salida para activar la válvula
const byte STOP_FORZADO = 4; // Boton para forzar el STOP del sistema
void setup() {
pinMode(MOTOR, OUTPUT);
pinMode(VALVULA, OUTPUT);
pinMode(STOP_FORZADO, INPUT);
digitalWrite(MOTOR, HIGH);
digitalWrite(VALVULA, HIGH);
Serial.begin(115200);
Serial.print("Comenzando XBEE");
}
void nodo_1() {
char tmp[3];
humedad = 0;
if (digitos[0] == 'A') { // Condición para identificar el caracter "A", para
// identificar el NODO 1
Serial.println("Nodo 1 HUMEDAD: ");
for (cont = 1; cont < 6; cont++) {
if (digitos[cont] != 'B') { // Condición para imprimir el valor de la
// humedad dada por el sensor del NODO 1
tmp[cont-1] = digitos[cont];
} else {
break;
}
}
humedad = atoi(tmp);
Serial.print("La humedad es de: ");
Serial.println(humedad);
Serial.println("%"); // Imprime el simbolo del procentaje una vez que
// digitos[cont] == 'B'
}
}
void loop() {
while (Serial.available() > 0) {
for (cont = 0; cont < 6; cont++) {
digitos[cont] = Serial.read();
Serial.print(digitos[cont]);
}
nodo_1();
}
delay(100);
}
Cre una variable de 3 caracteres que almacene el dato y luego lo convierto a entero usando atoi.
Podrias usar String y lograr lo mismo tal vez con mayor facilidad.
Hola nuevamente, hoy me presento con un último problema de mi proyecto de la red de sensores.
El proyecto total consistía en recibir la información de la humedad de los dos nodos hacia el coordinador, y en este se iba a encargar de exportar esos datos a la nube "BLYNK" en este caso.
El coordinador está encargado de activar un motor y una electroválvula las 7:30 am todos los días, y cuando llegue a la humedad necesaria estos actuadores se van desactivar; humedad la cual esta siendo proporcionada por los nodo 1 y nodo 2, y entonces la variación de humedad me está mostrando en blynk app en tiempo real.
Me funciona todo pero, pasa que se reinicia el programa a cada rato y ahí es donde se desconecta y conecta de la red wifi, y hay una perdida de datos a lo que llega a la plataforma blynk, además que como se reinicia a cada rato y las condiciones de las salidas para los relés, se setean y eso.
Cabe recalca que se reinicia a cada rato todo el programa y la verdad no se porque.
Espero que me puedan ayudar.
Adjunto el código.
//CODIGO QUE RECEPTA LOS DATOS DE LOS DOS NODOS SENSORES, ADEMAS DE ESO ESOS DATOS ENVÍA LA NUBE "BLYNK"
//EN BLYNK ME GRAFICA EL PORCENTAJE DE HUMEDAD QUE VA ADQUIRIENDO EN EL TIEMPO DE RIEGO,
//ESTE PROGRMA SE ENCARGA DE REALIZAR EL REGADÍO DE AGUA AUTOMATICAMENTE, TODOS LOS DÍAS A LAS 7:30 AM
//AL LLEGAR A SU SETPOINT O HUMEDAD IDEAL SE ENCARGA DE APAGAR LOS ACTUADORES
#include <ESP8266_Lib.h>
#include <BlynkSimpleShieldEsp8266.h>
#include <stdlib.h> /* atoi */
#include <SoftwareSerial.h>
#include <Wire.h>
#include <RTClib.h>
#define ESP8266_BAUD 9600
#define BLYNK_AUTH_TOKEN "_dkvGeenCZ3cZWNrrSH5vIBm8AnvhSJ5" //DIRECCIÓN QUE DIRIJE A LA PLATAFORMA BLYNK
#define BLYNK_PRINT Serial
SoftwareSerial EspSerial(2, 3); // RX, TX
ESP8266 wifi(&EspSerial);
BlynkTimer timer;
RTC_DS3231 rtc;
//-----------VARIABLES
char auth[] = BLYNK_AUTH_TOKEN;
char ssid[] = "NETLIFE-FLIA. CALAPAQUI";
char pass[] = "11061998bun";
char digitos[6];
int cont;
int porcentaje;
int humedad;
int humedad2;
bool evento_inicio = true; // variable de control para inicio de evento con valor true
bool evento_fin = true;
//----------------
//------DEFINICON DE ENTRADAS Y SALDIAS
const byte MOTOR =6;
const byte VALVULA = 7;
const byte PARE = 8;
//-------------------------------------
void nodo_1() {
char tmp[3];
humedad = 0;
if (digitos[0] == 'A') {
for (cont = 1; cont < 6; cont++) {
if (digitos[cont] != 'B') {
tmp[cont-1] = digitos[cont];
} else {
break;
}
}
humedad = atoi(tmp);
Blynk.virtualWrite(V3, humedad); //CON ESTA LINEA ME ENVIA LA INFORMACION DE LA HUMEDAD A "BLYNK";
}
}
void nodo_2() {
char tmp2[3];
humedad2 = 0;
if (digitos[0] == 'X') {
for (cont = 1; cont < 6; cont++) {
if (digitos[cont] != 'Y') {
tmp2[cont-1] = digitos[cont];
} else {
break;
}
}
humedad2 = atoi(tmp2);
Blynk.virtualWrite(V2, humedad2); //CON ESTA LINEA ME ENVIA LA INFORMACION DE LA HUMEDAD A "BLYNK";
}
}
void reloj(){ //FUNCIÓN DONDE ACTIVO LAS SALIDAS A LAS 7:30
DateTime fecha = rtc.now(); // funcion que devuelve fecha y horario en formato
if(fecha.hour() == 7 && fecha.minute() == 30){ //CONDICION PARA LA ACTIVACIÓN DE LOS RELES DE LA VALVULA Y MOTOR.
digitalWrite(VALVULA, LOW);
// delay(100);
digitalWrite(MOTOR, LOW);
}
}
void funcion(){
while (Serial.available() > 0) { //FUNCIÓN PARA LA RECEPCIÓN DE LOS VALORES DE LOS NODOS 1 Y 2
for (cont = 0; cont < 6; cont++) {
digitos[cont] = Serial.read();
}
nodo_1(); //LLAMO A LA FUNCIONES DE LOS NODOS
nodo_2();
}
}
void setup()
{
Serial.begin(9600);
EspSerial.begin(ESP8266_BAUD);
delay(10);
Blynk.begin(auth, wifi, ssid, pass);
if (! rtc.begin()) { // si falla la inicializacion del modulo
while (1); // bucle infinito que detiene ejecucion del programa
}
//rtc.adjust(DateTime(2022, 1, 5, 7, 18, 0)); // funcion que permite establecer fecha y horario. LE COMENTE PORQUE YA SE GUARDO LA HORA
//ADEMAS SI UTILIZÉ EL OTRO COAMANDO QUE MANDABA LA FECHA Y HORA ACTUALIZADA
timer.setInterval(1000L, funcion); //ESTA LINEA ES LA REALIZA EL ENVIO CONSTANTE DE LA INFROMACION DE LOS NODOS A LA PALTAFORMA BLYNK
pinMode(MOTOR, OUTPUT);
pinMode(VALVULA, OUTPUT);
pinMode(PARE, INPUT);
digitalWrite(MOTOR, HIGH); //CONDICIÓN PARA QUE LOS RELES ESTEN DESACTIVADOS
digitalWrite(VALVULA, HIGH);
}
void loop()
{
Blynk.run();
reloj();
timer.run();
if(humedad>=30 || humedad2>=30){
digitalWrite(MOTOR, HIGH);
// delay(100);
digitalWrite(VALVULA, HIGH);
}
}
Los ESP8266 son especiales.
Muchas veces algo que uno programa los pone en estos reinicios.
Busca Expressif y estudia como leer los reinicios poniendo el monitor serie en 78400 bps.
Podras ver porque lo hace. Esta codificado pero tendrás una idea de por donde van las balas.
