Ubidots Community

Configurar cantidad de datos a almacenar por dispositivo

Buenos días.
Quisiera saber si para las cuentas gratuitas se puede configurar la cantidad de datos almacenados por dispositivo, tengo un token asociado con un proyecto que cuenta con 5 sensores (dispositivos), la cosa es que el primer dispositivo almacena casi 1200 datos en 12 horas, el segundo solo 300 el tercero 20 y para los dos siguientes la cifra disminuye excesivamente.
Ese orden es el orden de envío de datos desde la configuración de codigo, no importa como organice los dispositivos en la Dashboard.
Agradezco cualquier ayuda.

Buen día @Colectorsolar,

Espero te encuentres bien.

Respondiendo a tu pregunta, Ubidots almacena todo los datos o información que se envíen de los sensores y no es posible establecer la cantidad de datos que se recibe de cada uno de estos. En este caso desde tu código tendrías que establecer la cantidad de datos a enviar y la frecuencia de envío, de esta manera puedes controlar que se reciban el mismo número de datos para cada dispositivo y a partir de esto realizar los análisis necesarios en Ubidots. A continuación te comparto nuestra documentación, donde podrás encontrar como enviar datos en los diferentes protocolos soportados.

Saludos,
-Isabel

Hola, te agradezco mucho por la ayuda creo que ya encontré el problema, pero me ayudarías mucho si me dijeses si es como yo creo o no, verás este es mi código, pero lo interesante esta en la línea 300 que es donde está lo de enviar datos a ubidots.

#include “BluetoothSerial.h”
#include <EEPROM.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#define TOKEN “BBFF-GozZ9MBxePlWS8lcTZBsUsOfI25vml” // Token asignado por Ubidots
#define MQTT_CLIENT_NAME “COLECTORSOLAR” // Nombre del cliente MQTT, ingrese su propia cadena ASCII de 8 a 12 caracteres alfanuméricos;

#include “max6675.h”

#define LED_BUILTIN 2
#define SENSOR 27

#define VARIABLE_LABEL_1 “Temperatura#1” // Asigna una etiqueta de variable única para enviar los datos de temperatura#1
#define VARIABLE_LABEL_2 “Temperatura#2” // Asigna una etiqueta de variable única para enviar los datos de temperatura#2
#define VARIABLE_LABEL_3 “Flujo” // Asigna una etiqueta de variable única para enviar los datos de Flujo
#define VARIABLE_LABEL_4 “Presion#1” // Asigna una etiqueta de variable única para enviar los datos de Presion#1
#define VARIABLE_LABEL_5 “Presion#2” // Asigna una etiqueta de variable única para enviar los datos de Presion#1
#define DEVICE_LABEL “Colector_Solar” // Asigna la etiqueta del dispositivo

char mqttBroker[] = “industrial.api.ubidots.com”;// “industrial.api.ubidots.com”,“things.ubidots.com
char dato1[100];
char dato2[100];
char dato3[100];
char dato4[100];
char dato5[100];
char var1[150];
char var2[150];
char var3[150];
char var4[150];
char var5[150];

// Espacio para almacenar valores a enviar.
char sensor1[10];
char sensor2[10];
char sensor3[10];
char sensor4[10];
char sensor5[10];

WiFiClient ubidots;
PubSubClient client(ubidots);
BluetoothSerial ESP_BT;
LiquidCrystal_I2C lcd(0x27, 16, 2);

String buffer_in;
unsigned long prevMillis = 0;
byte val;
int addr = 0;
byte indS=0;
byte indP=0;
String stream;
byte len=0;
String temp;
String temp2;
unsigned int intervalo=60000;
long currentMillis = 0;
long previousMillis = 0;
int interval = 1000;
boolean ledState = LOW;

const int pressureInput = 33;
const int pressureInput2 = 32;
const int pressureZero = 430;
const int pressureZero2 = 430;
const int pressureMax = 3686;
const int pressureMax2 = 3686;
const int pressuretransducermaxPSI = 72.04;
const int pressuretransducermaxPSI2 = 174.04;
float p1 = 0;
float p2 = 0;

volatile byte pulseCount;
byte pulse1Sec = 0;

float t, tF, t2, tF2;
float calibrationFactor = 4.5;
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;

int thermoDO = 19;
int thermoCS = 5;
int thermoCLK = 18;
MAX6675 thermocouple(thermoCLK, thermoCS, thermoDO);
int thermoDO2 = 26;
int thermoCS2 = 14;
int thermoCLK2 = 25;
MAX6675 thermocouple2(thermoCLK2, thermoCS2, thermoDO2);

void IRAM_ATTR pulseCounter()
{
pulseCount++;
}
void callback(char* topic, byte* payload, unsigned int length) {
char p[length + 1];
memcpy(p, payload, length);
p[length] = NULL;
String message(p);
Serial.write(payload, length);
Serial.println(topic);
}

/****************************************

  • Función reconectar
    ****************************************/
    void reconnect() {

while (!client.connected()) {
Serial.println(“Intentando conexcion MQTT…”);

if (client.connect(MQTT_CLIENT_NAME, TOKEN, "")) {
  Serial.println("Conectado");
} else {
  Serial.print("Fallo, rc=");
  Serial.print(client.state());
  Serial.println("Volver a intentar en 2 segundos");
  delay(200);
}

}
}

/****************************************

  • Funciones principales
    ****************************************/
    TaskHandle_t Task1;

void setup() {
xTaskCreatePinnedToCore(loop2, “Task1”, 10000, NULL, 1, NULL, 0);
EEPROM.begin(50);
Serial.begin(9600);
Serial.println(“Dispositivo bluetooth esta listo para emparejar”);
Serial.println(“Esperando 60 segundos para subir nuevas credenciales WIFI”);
ESP_BT.begin(“ESP32_BLUETOOTH”);
client.setServer(mqttBroker, 1883);
client.setCallback(callback);
pinMode(LED_BUILTIN, OUTPUT);
pinMode(SENSOR, INPUT_PULLUP);
pulseCount = 0;

flowRate = 0.0;
flowMilliLitres = 0;
totalMilliLitres = 0;
previousMillis = 0;

lcd.begin();
lcd.backlight();
lcd.setCursor(0,0);
lcd.print(“60s para cambiar”);
lcd.setCursor(0,1);
lcd.print(“credenciales”);

attachInterrupt(digitalPinToInterrupt(SENSOR), pulseCounter, FALLING);
while(!check_wifiUpdate()==true)
{
}

Serial.println("The Stored Wifi credetial are : ");
for(int i=0;i<50;i++)
{val=EEPROM.read(i);
stream+=(char)val;
if((val==10) && (indS==0))
{
indS=i;
Serial.println(“indS”+(String)i);
}
else if(val==10 && indP==0)
{
indP=i;
break;
Serial.println(“indP”+(String)i);
}
}

Serial.println(stream);
Serial.println(“Transmision finalizada”);
temp=stream.substring(0,indS);
temp=temp.substring(5,indS);

//ssid2=ssid;
temp2=stream.substring(indS+1,indP);
temp2=temp2.substring(5,indP-indS);

int i=temp.length();
int j=temp2.length();
char ssid[i];
char pass[j];
temp.toCharArray(ssid,i);
temp2.toCharArray(pass,j);

Serial.println(“SSID guardado”);
Serial.println(ssid);
Serial.println(“PASS guardado”);
Serial.println(pass);

WiFi.begin(ssid, pass);

if (WiFi.waitForConnectResult() != WL_CONNECTED) {
Serial.println(“WiFi Fallo”);
Serial.print(".");
delay(200);
Serial.println("");
Serial.println(“WiFi Conectado”);
Serial.println("Direccion: ");
Serial.println(WiFi.localIP());
client.setServer(mqttBroker, 1883);
client.setCallback(callback);

    while(1) {
        delay(1000);
    }
}
else 
{
  Serial.print("Wifi Conectado a: ");
  Serial.println(ssid);

}}

boolean check_wifiUpdate()
{
unsigned long correntMillis = millis();
if (correntMillis - prevMillis >= intervalo) {
prevMillis = correntMillis;

Serial.println("30 segundos mas");

return true;

}

else if (ESP_BT.available()){
  intervalo=50000;
buffer_in = ESP_BT.readStringUntil('\n'); 
Serial.println("Recibido:"); Serial.println(buffer_in);

delay(20);

if(buffer_in.charAt(0)==‘S’)
{
for(int i=0;i<buffer_in.length();i++)
{val=(byte)(buffer_in.charAt(i));
Serial.println("val "+val);

EEPROM.write(addr, val);
Serial.println(val);
addr++;
}
Serial.print("Nuevo ");
Serial.print(buffer_in);
EEPROM.write(addr, 10);
addr++;
EEPROM.commit();
ESP_BT.println(“SSID guardado”);
}

else if(buffer_in.charAt(0)==‘P’)
{
for(int i=0;i<buffer_in.length();i++)
{val=(byte)(buffer_in.charAt(i));
Serial.println("val "+val);
EEPROM.write(addr, val);
Serial.println(val);
addr++;

}
Serial.print("Nuevo ");
Serial.print(buffer_in);
EEPROM.write(addr, 10);
EEPROM.commit();
ESP_BT.println(“Password guardada”);
return true;
}

return false;
}
else
{ return false;
}
}

void loop2( void * pvParameters ){
for(;;){
sprintf(var1, “%s%s”, “/v1.6/devices/”, DEVICE_LABEL);
sprintf(var2, “%s%s”, “/v1.6/devices/”, DEVICE_LABEL);
sprintf(var3, “%s%s”, “/v1.6/devices/”, DEVICE_LABEL);
sprintf(var4, “%s%s”, “/v1.6/devices/”, DEVICE_LABEL);
sprintf(var5, “%s%s”, “/v1.6/devices/”, DEVICE_LABEL);
sprintf(dato1, “%s”, “”);
sprintf(dato2, “%s”, “”);
sprintf(dato3, “%s”, “”);
sprintf(dato4, “%s”, “”);
sprintf(dato5, “%s”, “”);
sprintf(dato1, “{”%s":", VARIABLE_LABEL_1);
sprintf(dato2, “{”%s":", VARIABLE_LABEL_2);
sprintf(dato3, “{”%s":", VARIABLE_LABEL_3);
sprintf(dato4, “{”%s":", VARIABLE_LABEL_4);
sprintf(dato5, “{”%s":", VARIABLE_LABEL_5);

/****************************************
 * Leemos el valor de cada uno de los sensores y lo asignamos a sus respectivas variables
 ****************************************/
  currentMillis = millis();
  if (currentMillis - previousMillis > interval) {
  
  pulse1Sec = pulseCount;
  pulseCount = 0;
  
  flowRate = ((1000.0 / (millis() - previousMillis)) * pulse1Sec) / calibrationFactor;
  previousMillis = millis();
  
  flowMilliLitres = (flowRate / 60) * 1000;
  
  totalMilliLitres += flowMilliLitres;
  
 p1 = analogRead(pressureInput); 
 p1 = ((p1-pressureZero)*pressuretransducermaxPSI)/(pressureMax-pressureZero);
 p2 = analogRead(pressureInput2); 
 p2 = ((p2-pressureZero)*pressuretransducermaxPSI2)/(pressureMax2-pressureZero2);

    t = thermocouple.readCelsius();
    tF = thermocouple.readFahrenheit();

    t2 = thermocouple2.readCelsius();
    tF2 = thermocouple2.readFahrenheit();

    
  }
  delay(500);    

  Serial.println(analogRead(pressureInput));
  Serial.println(analogRead(pressureInput2));
  Serial.print("Temperatura de Salida (Celsius) = ");
  Serial.println(t2);
  Serial.print("Temperatura de Salida (Farenheit) = ");
  Serial.println(tF2);
  Serial.print("Temperatura de Entrada (Celsius) = ");
  Serial.println(t);
  Serial.print("Temperatura de Entrada (Farenheit) = ");
  Serial.println(tF);
  Serial.print("Caudal del Flujo: ");
  Serial.print(int(flowRate));
  Serial.print("L/min");
  Serial.print("\t");
  Serial.print("Cantidad de Fluido Saliente: ");
  Serial.print(totalMilliLitres);
  Serial.print("mL / ");
  Serial.print(totalMilliLitres / 1000);
  Serial.println("L");
  Serial.print("Presion De Entrada Sensor#1 (PSI) = ");
  Serial.println(p1);
  Serial.print("Presion De Salida Sensor#2 (PSI) = ");
  Serial.println(p2);
  Serial.println("\t");
  delay(2000);

  /* 4 es el ancho mínimo, 2 es la precisión; el valor flotante se copia en las variables sensor*/
  dtostrf(t, 4, 2, sensor1);
  dtostrf(t2, 4, 2, sensor2);
  dtostrf(int(flowRate), 4, 2, sensor3);
  dtostrf(p1, 4, 2, sensor4);
  dtostrf(p2, 4, 2, sensor5);
  sprintf(dato1, "%s {\"value\": %s}}", dato1, sensor1); // Agrega el valor
  sprintf(dato2, "%s {\"value\": %s}}", dato2, sensor2); // Agrega el valor
  sprintf(dato3, "%s {\"value\": %s}}", dato3, sensor3); // Agrega el valor
  sprintf(dato4, "%s {\"value\": %s}}", dato4, sensor4); // Agrega el valor
  sprintf(dato5, "%s {\"value\": %s}}", dato5, sensor5); // Agrega el valor
  delay(1000);

}
}

void loop() {
if (!client.connected()) {
reconnect();
}
if (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(200);
Serial.println("");
Serial.println(“WiFi Connectado”);
Serial.println("Direccion: ");
Serial.println(WiFi.localIP());
client.setServer(mqttBroker, 1883);
client.setCallback(callback);
}
client.publish(var1, dato1);
client.publish(var2, dato2);
client.publish(var3, dato3);
client.publish(var4, dato4);
client.publish(var5, dato5);

{
lcd.clear();  

lcd.setCursor(0,0);
lcd.print("TEMP. ENTRADA:");
lcd.setCursor(0,1);
lcd.print(t,1);
lcd.print("C");
}
delay(2000);
lcd.clear();
{
lcd.setCursor(0,0);
lcd.print("TEMP. DE SALIDA:");
lcd.setCursor(0,1);
lcd.print(t2,1);
lcd.print("C");
}
delay(2000);

lcd.clear();
{
lcd.setCursor(0,0);
lcd.print("PRES. ENTRADA:");
lcd.setCursor(0,1);
lcd.print(p1,1);
lcd.print("PSI");
}
delay(2000);
lcd.clear();
{
lcd.setCursor(0,0);
lcd.print("PRES. DE SALIDA:");
lcd.setCursor(0,1);
lcd.print(p2,1);
lcd.print("PSI");
}
delay(2000);

lcd.clear();
{
lcd.setCursor(0,0);
lcd.print("CAUDAL:");
lcd.setCursor(0,1);
lcd.print(int(flowRate));
lcd.print("L/min");
}
delay(2000);

}

Creo que el problema es que me falta lo de la foto

Agradezco cualquier ayuda… De verdad que sí, ya que es mi proyecto de grado