Show Posts
Pages: 1 [2] 3 4 ... 37
16  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 12, 2014, 05:09:10 pm
Bueno. Alivia saber que el último código hace las lecturas correctamente. Había un error en el log, ya que imprimía antes los valores que la etiqueta, y aparecían desplazados; pero ya está solucionado. El código para el arduino esclavo, incluyendo el envío de datos por i2c, podría quedar así:
Code:
#include <AltSoftSerial.h>          //Include the software serial library 
#include <Wire.h>

const byte i2c_address=0x77;
AltSoftSerial altSerial;            //Name the software serial library altSerial (this cannot be omitted) 

int s0 = 7;                         //Arduino pin 7 to control pin S0
int s1 = 6;                         //Arduino pin 6 to control pin S1

char sensordata[30];                 //A 30 byte character array to hold incoming data from the sensors
byte sensor_bytes_received=0;        //We need to know how many characters bytes have been received

struct data
{
     struct {
          float ec;
          float tds;
          float sal;
          float sg;
     }
     conductivity;
     float pH;
     float DO;
     float ORP;
     float temperature;
};

const int data_size=sizeof(data);

const int waiting_time = 1000;

data data_from_sensors = {
     {
          0, 0, 0, 0           }
     ,
     0,
     0,
     0,
     0
};

void setup() {
     pinMode(s1, OUTPUT);              //Set the digital pin as output.
     pinMode(s0, OUTPUT);              //Set the digital pin as output.
     pinMode(2, OUTPUT);               //Set pin 2 as an output
     Serial.begin(38400);              //Set the hardware serial port to 38400
     altSerial.begin(38400);           //Set the soft serial port to 38400
     Wire.begin(i2c_address);
     Wire.onRequest(requestEvent);
}





void loop(){
     data_from_sensors.temperature = read_temp();
     open_channel(0);
     Serial.print("Conductivity==>");
     altSerial.print("R\r");
     leeBuffer();
     const char *delimitador=",";
     data_from_sensors.conductivity.ec=atof(strtok(sensordata,delimitador));
     data_from_sensors.conductivity.tds=atof(strtok(NULL,delimitador));
     data_from_sensors.conductivity.sal=atof(strtok(NULL,delimitador));
     data_from_sensors.conductivity.sg=atof(strtok(NULL,delimitador));
     
     open_channel(1);
     Serial.print("pH==>");
     altSerial.print("R\r");
     leeBuffer();
     data_from_sensors.pH=atof(sensordata);

     open_channel(2);
     Serial.print("DO==>");
     altSerial.print("R\r");
     leeBuffer();
     data_from_sensors.DO=atof(sensordata);

     open_channel(3);
     Serial.print("ORP==>");
     altSerial.print("R\r");
     leeBuffer();
     data_from_sensors.ORP=atof(sensordata);

      Serial.println();
      Serial.println(" DATA IN STRUCTURE ");
      Serial.println("-------------------");
      Serial.print("Conductividad==> EC: ");
      Serial.print(data_from_sensors.conductivity.ec);
      Serial.print(", TDS: ");
      Serial.print(data_from_sensors.conductivity.tds);
      Serial.print(", SAL: ");
      Serial.print(data_from_sensors.conductivity.sal);
      Serial.print(", SG: ");
      Serial.println(data_from_sensors.conductivity.sg);
     
      Serial.print("pH==> ");
      Serial.println(data_from_sensors.pH);
      Serial.print("DO==> ");
      Serial.println(data_from_sensors.DO);
      Serial.print("ORP==> ");
      Serial.println(data_from_sensors.ORP);
     
      // resto de datos de la estructura
      Serial.print("Temperatura==> ");
      Serial.println(data_from_sensors.temperature);
     
      Serial.println("-------------------");
      Serial.println(" DATA IN STRUCTURE END ");
      Serial.println();
      delay(5000);
}

void leeBuffer(){
     delay(waiting_time);
     if(altSerial.available() > 0){                   //If data has been transmitted from an Atlas Scientific device
          sensor_bytes_received=altSerial.readBytesUntil(13,sensordata,30); //we read the data sent from the Atlas Scientific device until we see a <CR>. We also count how many character have been received
          sensordata[sensor_bytes_received]=0;           //we add a 0 to the spot in the array just after the last character we received. This will stop us from transmitting incorrect data that may have been left in the buffer
          Serial.println(sensordata);
     }
}

void open_channel(int channel){                                  //This function controls what UART port is opened.

     if (channel & 1){
          digitalWrite(s0, HIGH);
     }
     else {
          digitalWrite(s0,LOW);
     }
     if (channel & 2){
          digitalWrite(s1, HIGH);
     }
     else {
          digitalWrite(s1,LOW);
     }
     delay(100);
     int bytesResiduo=altSerial.available();
     if(bytesResiduo > 0){
          sensor_bytes_received=altSerial.readBytes(sensordata, bytesResiduo);
          sensordata[bytesResiduo]=0;
          Serial.print("ATENCION: DATOS NO LEIDOS: ");
          Serial.println(sensordata);
     }
}

float read_temp(void){   //the read temperature function
     float v_out;             //voltage output from temp sensor
     float temp;              //the final temperature is stored here
     digitalWrite(A0, LOW);   //set pull-up on analog pin
     digitalWrite(2, HIGH);   //set pin 2 high, this will turn on temp sensor
     delay(2);                //wait 2 ms for temp to stabilize
     v_out = analogRead(0);   //read the input pin
     digitalWrite(2, LOW);    //set pin 2 low, this will turn off temp sensor
     v_out*=.0048;            //convert ADC points to volts (we are using .0048 because this device is running at 5 volts)
     v_out*=1000;             //convert volts to millivolts
     temp= 0.0512 * v_out -20.5128; //the equation from millivolts to temperature
     return temp;             //send back the temp
}

void requestEvent(){
      byte *pDatos= (byte *) &data_from_sensors;
      Wire.write(pDatos, data_size);
}

En principio, lo único que debería hacer es, cuando reciba una petición del master (onRequest), enviar la estructura que contiene los datos. Por ello no he implementado función de recepción (onReceive), ya que en principio el master no nos va a enviar nada. Posteriormente se podrían crear comandos para calibrar, chequear o qué se yo, y entonces habría que implementar el onReceive e interpretar los datos recibidos.
Como cosillas a depurar, aparte de los posibles fallos en este código:
- La longitud de la estructura, si no me equivoco, es de 32 bytes, ya que estamos enviando ocho números float. El buffer de recepción de i2c creo que tiene ese tamaño justo, así que si no está previamente limpio como una patena, podemos tener problemas. Creo que con un pequeño truco podríamos reducir el tamaño de la estructura a la mitad, con lo que además de tener menos complicaciones de buffer, el dato tardará la mitad de tiempo en transmitirse. Pero para no liarla debemos conocer los rangos entre los que van a estar los datos (máximo, mínimo y número de decimales).
- La interrupción i2c podría producirse a mitad de actualización de nuestros datos, con lo que el buffer se podría enviar "a medio peinar" con algún dato incorrecto. La solución podría ser utilizar dos estructuras para grabar los datos alternativamente, y marcar una como estructura a enviar y otra como estructura para grabar los nuevos datos. Cuando terminamos de grabar los datos, alternamos esa marca.
- No sé la magnitud de la variación de los otros parámetros en función de la temperatura. Te corresponde a tí determinar si quieres leer dándole ese dato a los sensores o no. Hay, además, en el sensor de O2 (creo) otra variable que puede modificar la lectura que creo que es la EC, y aunque no se envíe el dato exacto, creo que no está de más indicar al menos si es agua dulce o salada. Todo este tema te lo dejo a tu criterio, pues yo no sé ni qué son los datos. A propósito, el de temperatura no sé si está mal leído o es que viene en farenheit o qué se yo, pues no me parecen temperaturas muy normales.

He estado bicheando también entre los códigos del openrov y creo que he conseguido implementar una primera versión del sensor. Ya te explico en otro post.
Saludos.
17  International / Software / Re: Agradecería ayuda con código para medidor de humedad y 74HC595 2 digitos. on: September 12, 2014, 04:26:11 pm
Hola.
En primer lugar, deberías explicar un poco más concretamente tu problema: si es para leer el sensor, calcular los dígitos o para mostrarlos...
En segundo lugar, para códigos cortos como el tuyo, lo mejor es mostrar el código en el propio mensaje (seguro que más gente se animará a echarle un vistazo). Para ello, selecciona en el IDE todo el código, y aquí en el editor pulsas el icono de almohadilla que hay en la parte superior, y pegas tu código entre las dos etiquetas que aparecen:
 [ code ]  tal que aquí  [ /code]
Y en tercer lugar, no debería ser necesario que reescribas la función shiftOut.
Saludos.
18  International / Español / Re: Pulsador de acceso universal on: September 12, 2014, 03:52:09 pm
Hola.
Tiempo ha, realicé un código en C que hacía exactamente eso: enviar o recibir morse. Suponiendo que ya tienes optimizado el código para distinguir las pulsaciones de punto o raya, y evitar problemas de rebote, te cuento, así de memoria, en pseudocódigo, cómo lo realicé yo para almacenar los valores en variables tipo byte.

-Si llevamos más de x tiempo sin recibir pulsación, guardamos el byte_recibido y reiniciamos su a 1. Esto es así, porque como los códigos no son de la misma longitud, el primer bit a 1 que recibamos no va a significar punto o raya, sino sencillamente que a continuación empieza el código. Por ejemplo, la A
                 . _      se almacenaría como
000001/01. Osea, el primer 1 de la izquierda nos indica que a continación comienza el código, que sería un cero (punto) y un uno (raya). Asimismo, la L (._..) se representaría como 0001/0100. Espero haberme explicado.

- Si recibimos un punto o una raya, lo que haremos será desplazar hacia la izquierda el byte que estamos recibiendo, y poner en el bit 0 un 1 en caso de raya (en el caso de punto lo dejamos a cero, que es como queda por defecto tras el desplazamiento.
if (pulsacion) {
    byte_recibido<<=1;
    if (pulsacion_larga)  byte_recibido|=1;
}

El proceso para "crear" una P (.__.) haría que byte_recibido pasara por estos estados:
00000001=>valor inicial
00000010=> .
00000101=>_
00001011=>_
00010110=>.

Espero haberme explicado. Si tienes alguna duda, no dudes en preguntar.
Saludos.
19  International / Software / Re: Tabla de la verdad con Arduino on: September 11, 2014, 06:10:53 pm

Para aclarar el UNO "NO" tiene puerto A solo B, C y D.


Cierto... Sorry. Es lo que tiene contestar sin revisar el pinout, y mira que esa información estaba en el propio vínculo que puse  smiley-red
20  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 11, 2014, 03:43:47 pm
Bueno. Dada la inquietud que me embriaga con el diferente funcionamiento de dos códigos tan equivalentes (llámame tikismikis, pero no doy por sentado que estemos leyendo bien sólo porque llenemos todas las variables), he decidido modificar un poco el código y volver al antiguo buffer, principalmente para ver qué cadena recibimos y si el error es al convertir o al recibir. También he agregado un vaciado de buffer  inmediatamente a cambiar de canal (podría hacer simplemente un flush, pero de paso vemos qué ha quedado), pues cabe la posibilidad de que datos no leídos de un sensor que estuvieran en el buffer se interpreten como datos del nuevo canal o simplemente estén entorpeciendo la nueva lectura.
Prueba a ver el código y me cuentas. Creo que ya va siendo hora de comenzar a construir nuestro device. A ver si mañana podemos hacer algo.
En un futuro, supongo (aunque de esto entenderás tú más que yo) que habrá que trabajar otros comandos para realizar lecturas compensadas (por ejemplo, creo que la temperatura influye en casi todas y por eso la he puesto al principio).
Saludos.

Code:
#include <AltSoftSerial.h>          //Include the software serial library 
#include <string.h>
AltSoftSerial altSerial;            //Name the software serial library altSerial (this cannot be omitted) 

int s0 = 7;                         //Arduino pin 7 to control pin S0
int s1 = 6;                         //Arduino pin 6 to control pin S1

char sensordata[30];                 //A 30 byte character array to hold incoming data from the sensors
byte sensor_bytes_received=0;        //We need to know how many characters bytes have been received

struct data
{
     struct {
          float ec;
          float tds;
          float sal;
          float sg;
     }
     conductivity;
     float pH;
     float DO;
     float ORP;
     float temperature;
};

const int waiting_time = 1000;

data data_from_sensors = {
     {
          0, 0, 0, 0           }
     ,
     0,
     0,
     0,
     0
};

void setup() {
     pinMode(s1, OUTPUT);              //Set the digital pin as output.
     pinMode(s0, OUTPUT);              //Set the digital pin as output.
     pinMode(2, OUTPUT);               //Set pin 2 as an output
     Serial.begin(38400);              //Set the hardware serial port to 38400
     altSerial.begin(38400);           //Set the soft serial port to 38400
}





void loop(){
     data_from_sensors.temperature = read_temp();
     open_channel(0);
     altSerial.print("R\r");
     leeBuffer();
     const char *delimitador=",";
     Serial.print("Conductivity==>");
     data_from_sensors.conductivity.ec=atof(strtok(sensordata,delimitador));
     data_from_sensors.conductivity.tds=atof(strtok(NULL,delimitador));
     data_from_sensors.conductivity.sal=atof(strtok(NULL,delimitador));
     data_from_sensors.conductivity.sg=atof(strtok(NULL,delimitador));
     
     open_channel(1);
     altSerial.print("R\r");
     leeBuffer();
     Serial.print("pH==>");
     data_from_sensors.pH=atof(sensordata);

     open_channel(2);
     altSerial.print("R\r");
     leeBuffer();
     Serial.print("DO==>");
     data_from_sensors.DO=atof(sensordata);

     open_channel(3);
     altSerial.print("R\r");
     leeBuffer();
     Serial.print("ORP==>");
     data_from_sensors.ORP=atof(sensordata);

      Serial.println("  ");
      Serial.println(" DATA IN STRUCTURE ");
      Serial.println("  ");
      Serial.print("Conductividad==> EC: ");
      Serial.print(data_from_sensors.conductivity.ec);
      Serial.print(", TDS: ");
      Serial.print(data_from_sensors.conductivity.tds);
      Serial.print(", SAL: ");
      Serial.print(data_from_sensors.conductivity.sal);
      Serial.print(", SG: ");
      Serial.println(data_from_sensors.conductivity.sg);
     
      Serial.print("pH==> ");
      Serial.println(data_from_sensors.pH);
      Serial.print("DO==> ");
      Serial.println(data_from_sensors.DO);
      Serial.print("ORP==> ");
      Serial.println(data_from_sensors.ORP);
     
      // resto de datos de la estructura
      Serial.print("Temperatura==> ");
      Serial.println(data_from_sensors.temperature);
     
      Serial.println("  ");
      Serial.println(" DATA IN STRUCTURE END ");
      Serial.println("  ");
      delay(5000);
}

void leeBuffer(){
     delay(waiting_time);
     if(altSerial.available() > 0){                   //If data has been transmitted from an Atlas Scientific device
          sensor_bytes_received=altSerial.readBytesUntil(13,sensordata,30); //we read the data sent from the Atlas Scientific device until we see a <CR>. We also count how many character have been received
          sensordata[sensor_bytes_received]=0;           //we add a 0 to the spot in the array just after the last character we received. This will stop us from transmitting incorrect data that may have been left in the buffer
          Serial.println(sensordata);
     }
}

void open_channel(int channel){                                  //This function controls what UART port is opened.

     if (channel & 1){
          digitalWrite(s0, HIGH);
     }
     else {
          digitalWrite(s0,LOW);
     }
     if (channel & 2){
          digitalWrite(s1, HIGH);
     }
     else {
          digitalWrite(s1,LOW);
     }
     delay(100);
     int bytesResiduo=altSerial.available();
     if(bytesResiduo > 0){
          sensor_bytes_received=altSerial.readBytes(sensordata, bytesResiduo);
          sensordata[bytesResiduo]=0;
          Serial.print("ATENCION: DATOS NO LEIDOS: ");
          Serial.println(sensordata);
     }
}

float read_temp(void){   //the read temperature function
     float v_out;             //voltage output from temp sensor
     float temp;              //the final temperature is stored here
     digitalWrite(A0, LOW);   //set pull-up on analog pin
     digitalWrite(2, HIGH);   //set pin 2 high, this will turn on temp sensor
     delay(2);                //wait 2 ms for temp to stabilize
     v_out = analogRead(0);   //read the input pin
     digitalWrite(2, LOW);    //set pin 2 low, this will turn off temp sensor
     v_out*=.0048;            //convert ADC points to volts (we are using .0048 because this device is running at 5 volts)
     v_out*=1000;             //convert volts to millivolts
     temp= 0.0512 * v_out -20.5128; //the equation from millivolts to temperature
     return temp;             //send back the temp
}

21  International / Software / Re: Tabla de la verdad con Arduino on: September 11, 2014, 03:20:02 pm
Hola.
He puesto PORTB como ejemplo, al igual que podría haber puesto PORTA. Creo que ambos existen en el UNO. Arduino, al igual que PIC, también permite manipulación directa de puertos. De hecho las instrucciones de manejo de pines, generalmente más recomendables, pues evitan posibles errores nuestros  al trabajar con puertos completos, internamente son convertidas a instrucciones de puerto.
22  International / Software / Re: Tabla de la verdad con Arduino on: September 11, 2014, 11:03:10 am
Hola.
Hay varias formas de implementar lo que dices. En el caso que propones, la solución de max_saeta está muy bien, ya que sencillamente devuelven dos valores en función de otro.
Sin embargo, igual me equivoco, creo que lo que tú estás buscando se corresponde a las funciones switch-case.
Ejemplo:

Code:
byte entrada=PORTB & B111;
      switch (entrada){
            case B000:
                  Serial.println("Vacio");
                  // resto de comandos, incluyendo llamadas a funciones
                  break;
            case B001:
                  Serial.println("Llenando");
                  break;
            case B011:
                  Serial.println("Lleno");
                  break;
            case B111:
                  Serial.println("Rebose");
                  break;
            default:     // esto se ejecutaría en el resto de casos.
                  Serial.println("Alarma");
                  break;
      } 
¿Es eso lo que buscabas?
23  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 10, 2014, 11:20:11 am
Aún no he echado un vistazo a los otros datashields, pero; ¿No será que están enviando algún dato no numérico? ¿No tendrán también activada alguna respuesta tipo el *OK del primero?
24  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 10, 2014, 08:59:10 am
Hola.
Prueba estas pequeñas modificaciones en el loop, a ver si obtienes mismo resultado.
Code:
      open_channel(0);
      waiting_time = 1000;
      ////////////////////////////////// COMIENZO CÓDIGO DE LECTURA DE CONDUCTIVIDAD /////////////////////////////
      // delay(1); // Tal vez sea necesario un pequeño delay antes de comenzar el envío
      altSerial.print(cmd);                         //Send the command from the computer to the Atlas Scientific device using the softserial port
      delay(waiting_time); // esperamos el segundo estipulado en el manual.
      if(altSerial.available() > 0){                   //If data has been transmitted from an Atlas Scientific device
            data_from_sensors.conductivity.ec=altSerial.parseFloat();
            data_from_sensors.conductivity.tds=altSerial.parseFloat();
            data_from_sensors.conductivity.sal=altSerial.parseFloat();
            data_from_sensors.conductivity.sg=altSerial.parseFloat();
      }
      ////////////////////////////////// FINAL CÓDIGO DE LECTURA DE CONDUCTIVIDAD. HAY QUE HACER UNO SIMILAR PARA LOS OTROS /////////////////////////////
     
     
      /*RESTO DE SENSORES*/
     
      data_from_sensors.temperature = read_temp();       //call the function “read_temp” and return the temperature in C°
     
      waiting_time = 500;                    // vamos a dar un poco más de tiempo a la respuesta, por si acaso se está cortando en algún caso por buffer vacío
      open_channel(1);                               //Call the function "open_channel" to open the correct data path
      delay(100);
      altSerial.print(cmd);                         //Send the command from the computer to the Atlas Scientific device using the softserial port
      //altSerial.print("\r");                        //No es necesario, porque la cadena cmd ya incluye el \r
      delay(waiting_time);
      if(altSerial.available() > 0){                   //If data has been transmitted from an Atlas Scientific device
          data_from_sensors.pH=altSerial.parseFloat();
      }
     
      open_channel(2);                               //Call the function "open_channel" to open the correct data path
      delay(100);
      altSerial.print(cmd);                         //Send the command from the computer to the Atlas Scientific device using the softserial port
      delay(waiting_time);
      if(altSerial.available() > 0){                   //If data has been transmitted from an Atlas Scientific device
          data_from_sensors.DO=altSerial.parseFloat();
      }
     
      open_channel(3);                               //Call the function "open_channel" to open the correct data path
      delay(100);
      altSerial.print(cmd);                         //Send the command from the computer to the Atlas Scientific device using the softserial port
      delay(waiting_time);
      if(altSerial.available() > 0){                   //If data has been transmitted from an Atlas Scientific device
          data_from_sensors.ORP=altSerial.parseFloat();
      }
     
      /*FINAL DEL RESTO DE SESORES*/
25  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 10, 2014, 07:06:33 am
Pues si vas a desactivar el *OK, el código de recepción quedaría más o menos así:

Code:
      altSerial.print(cmd);                         //Send the command from the computer to the Atlas Scientific device using the softserial port
      delay(1000); // esperamos el segundo estipulado en el manual. Podemos intentar con menos, pero si no hay prisa, mejor asegurar.
      if(altSerial.available() > 0){                   //If data has been transmitted from an Atlas Scientific device
            data_from_sensors.conductivity.ec=altSerial.parseFloat();
            data_from_sensors.conductivity.tds=altSerial.parseFloat();
            data_from_sensors.conductivity.sal=altSerial.parseFloat();
            data_from_sensors.conductivity.sg=altSerial.parseFloat();
      }

El resto de los sensores se manejaría de forma muy similar, supongo, salvo que sólo necesitas poner un parsefloat, en lugar de cuatro, y el delay necesario será menor. Puedes quitar de momento las variables sensordata[30] y sensor_bytes_received, ya que no las estamos usando. Prueba a ver si lo consigues.  Dame tiempo para ojear los datasheets.

Saludos.
26  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 09, 2014, 06:02:08 pm
Pues la salida de mi código no es la deseada, ya que debería devolver primero
Ok conductividad==> *OK
Y luego tomar las medidas. Supongo que sea que está activada la lectura continua. Habrá que enviar en el setup el comando "C,0\n" para asegurarse de que se desactiva el modo de lecturas continuas (que queda por defecto tras resetear el módulo).
Prueba el último código que te pasé, pero asegúrate de que está funcionando en modo de lectura simple, a ver si nos aparece el *OK.
Saludos.

Pásame, si tienes, enlace a los datasheets de los otros dispositivos a ver qué instrucciones reciben y qué códigos devuelven.

EDITO: parseFloat lee del puerto correspondiente hasta que encuentra un carácter no numérico (o deja de reciir datos) y convierte a número flotante. Asimismo parseInt hace lo propio con los enteros.
27  International / Proyectos / Re: Cambio de sensor de nivel ayuda on: September 09, 2014, 05:29:22 pm
Lo del datalogger no es necesario implementarlo en sí finalmente. Su utilidad es principalmente analizar patrones a buscar para establecer los puntos de cálculo. Si no tienes un shield SD o ethernet, podrías realizar log por el puerto serie en el monitor serie o, un poco más elaborado, con otro terminal. Podrías analizar datos de altura cada x tiempo, o datos de tiempo cuando hay una variación.
28  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 09, 2014, 09:31:35 am
Bueno; casi. Faltan un par de cosas. Primeramente vamos a deshacer el bucle for, puesto que cada uno de los sensores va a ser tratado de forma diferente (se extraerá a su variable dentro de la estructura). De paso deberíamos realizar una lectura más "segura". No he visto los datasheets de los otros sensores, pero en el de conductividad el proceso debería ser, más o menos:

- Enviar el comando "R"
- Recibir la contestación y verificar que ésta sea "*OK". Si la contestación no es esa, tampoco podemos esperar que lo que viene después sea el dato correcto y deberíamos tomar otra decisión.
- Si la contestación fue OK, esperar un segundo y recibir el dato, que ahora sí debería ser una respuesta al comando que hemos enviado.

Te envío un código hecho al vuelo con la parte del sensor de conductividad. A ver si funciona y si puedes realizar de forma similar la carga en la estructura del resto de datos, teniendo en cuenta cómo son sus respuestas según sus datasheets.
Code:
#include <AltSoftSerial.h>          //Include the software serial library 
AltSoftSerial altSerial;            //Name the software serial library altSerial (this cannot be omitted) 

int s0 = 7;                         //Arduino pin 7 to control pin S0
int s1 = 6;                         //Arduino pin 6 to control pin S1

char sensordata[30];                 //A 30 byte character array to hold incoming data from the sensors
byte sensor_bytes_received=0;        //We need to know how many characters bytes have been received

char *cmd = "R\r";                           //Char pointer used in string parsing

float temp;                //where the final temperature data is stored

struct data
{
      struct {
            float ec;
            float tds;
            float sal;
            float sg;
      } conductivity;
      float pH;
      float DO;
      float ORP;
      float temperature;
};

int waiting_time = 340;

data data_from_sensors = {
      {
            0, 0, 0, 0      }
      ,
      0,
      0,
      0,
      0
};

void setup() {
      pinMode(s1, OUTPUT);              //Set the digital pin as output.
      pinMode(s0, OUTPUT);              //Set the digital pin as output.
      pinMode(2, OUTPUT);               //Set pin 2 as an output
      Serial.begin(38400);              //Set the hardware serial port to 38400
      altSerial.begin(38400);           //Set the soft serial port to 38400
}





void loop(){

      open_channel(1);
      ////////////////////////////////// COMIENZO CÓDIGO DE LECTURA DE CONDUCTIVIDAD /////////////////////////////
      // delay(1); // Tal vez sea necesario un pequeño delay antes de comenzar el envío
      altSerial.print(cmd);                         //Send the command from the computer to the Atlas Scientific device using the softserial port
      if(altSerial.available() > 0){                   //If data has been transmitted from an Atlas Scientific device
            sensor_bytes_received=altSerial.readBytesUntil(13,sensordata,30); //we read the data sent from the Atlas Scientific device until we see a <CR>. We also count how many character have been received
            sensordata[sensor_bytes_received]=0;           //we add a 0 to the spot in the array just after the last character we received. This will stop us from transmitting incorrect data that may have been left in the buffer
            Serial.print("Ok Conductividad==> ");
            Serial.println(sensordata); // aquí deberíamos recibir un *OK. Posteriormente controlaremos que así sea. De momento sólo lo imprimimos.
            delay(1000); // esperamos el segundo estipulado en el manual.
            data_from_sensors.conductivity.ec=altSerial.parseFloat();
            data_from_sensors.conductivity.tds=altSerial.parseFloat();
            data_from_sensors.conductivity.sal=altSerial.parseFloat();
            data_from_sensors.conductivity.sg=altSerial.parseFloat();
      }
      ////////////////////////////////// FINAL CÓDIGO DE LECTURA DE CONDUCTIVIDAD. HAY QUE HACER UNO SIMILAR PARA LOS OTROS /////////////////////////////
     
      data_from_sensors.temperature = read_temp();       //call the function “read_temp” and return the temperature in C°
     
      // Aquí deberían estar cargados los datos en nuestra estructura. De momento los imprimimos.
      Serial.print("Conductividad==> EC: ");
      Serial.print(data_from_sensors.conductivity.ec);
      Serial.print(", TDS: ");
      Serial.print(data_from_sensors.conductivity.tds);
      Serial.print(", SAL: ");
      Serial.print(data_from_sensors.conductivity.sal);
      Serial.print(", SG: ");
      Serial.println(data_from_sensors.conductivity.sg);
      // resto de datos de la estructura
      Serial.print("Temperatura");
      Serial.println(data_from_sensors.temperature);
     
      delay(5000);
}


void open_channel(int channel){                                  //This function controls what UART port is opened.

      if (channel & 1){
            digitalWrite(s0, HIGH);
      }
      else {
            digitalWrite(s0,LOW);
      }

      if (channel & 2){
            digitalWrite(s1, HIGH);
      }
      else {
            digitalWrite(s1,LOW);
      }
}

float read_temp(void){   //the read temperature function
      float v_out;             //voltage output from temp sensor
      float temp;              //the final temperature is stored here
      digitalWrite(A0, LOW);   //set pull-up on analog pin
      digitalWrite(2, HIGH);   //set pin 2 high, this will turn on temp sensor
      delay(2);                //wait 2 ms for temp to stabilize
      v_out = analogRead(0);   //read the input pin
      digitalWrite(2, LOW);    //set pin 2 low, this will turn off temp sensor
      v_out*=.0048;            //convert ADC points to volts (we are using .0048 because this device is running at 5 volts)
      v_out*=1000;             //convert volts to millivolts
      temp= 0.0512 * v_out -20.5128; //the equation from millivolts to temperature
      return temp;             //send back the temp
}

Saludos.
29  International / Software / Re: Equivalencia e de conversión de variables on: September 09, 2014, 08:38:26 am
Tal y como figura en la imagen del hilo que mencionas es correcto.
Estas tres declaraciones deberían ser equivalentes.
Code:
byte MiVariable[8] = { B00000, B00001, B00011, B10110, B11100, B01000, B00000 };
byte MiVariable[8] = { 0x0, 0x1, 0x3, 0x16, 0x1c, 0x8, 0x0};
byte MiVariable[8] = { 0, 1, 3, 22, 28, 8, 0 };
Si no me he equivocado en algún cálculo.
Saludos.
30  International / Proyectos / Re: Cambio de sensor de nivel ayuda on: September 08, 2014, 06:04:47 pm
Bueno. Claro que es posible, hombre. Puedes simplemente indicar con un pulsador el inicio y final de llenado, por ejemplo. Si quieres que el micro lo detecte por sí, lo que hay que saber es de qué forma se produce el llenado o vaciado; principalmente la velocidad. Entonces, controlando el tiempo y la medida (velocidad de llenado o vaciado) deberíamos poder detectar cuándo podemos dar por finalizado el llenado (y calcular la diferencia). Luego se podrá complicar la cosa tanto como se quiera (Hacer medias de las medidas, establecer umbrales de variación para no detectar falsos llenados...). 
Un buen comienzo sería monitorizar y estudiar lecturas cada cinco minutos (por ejemplo) durante un tiempo de uso que incluya un llenado, a ver primero cómo lo harías tú a ojo, y después intentar decirle al arduino cómo decidir eso mismo.
Saludos.
Pages: 1 [2] 3 4 ... 37