Show Posts
Pages: 1 2 [3] 4 5 ... 38
31  International / Software / Re: Agradecería ayuda con código para medidor de humedad y 74HC595 2 digitos. on: September 15, 2014, 06:14:03 am
¿Qué código tienes actualmente?
32  International / Hardware / Re: I2C con 2 arduinos esclavos. on: September 15, 2014, 03:00:29 am
Hola, javikomu.
Como ya te comenté, en hardware/electrónica poco te puedo ayudar, pero creo que sería provechoso que explicaras más detalladamente a maxid cómo van a ir conectados los dispositivos, y cómo van a ir alimentados (transformador AC, fuente de alimentación, baterías...), porque, por ejemplo, los arduinos no "van" a 7V, sino a 5V. Se alimentan con 7-12V a través de la clavija, pero si dispones de una fuente estable de 5V puedes alimentarlo directamente por Vin. El sensor podría incluso tomar su alimentación de la salida de 3v de uno de los arduinos si el consumo no es muy elevado y la distancia lo permite.  No estaría de más un esquema de cómo piensas alimentarlo todo.
Lo que sí que parece claro es que tendrás que adaptar la tensión de los pines de comunicación, pues los pines de arduino trabajan con 0-5 y los de tu sensor con 0-3.

Saludos
33  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 13, 2014, 05:13:56 pm
Uffff. Lo siento.
Con la electrónica y el menda acabas de pinchar en hueso. Prefiero no arriesgarme a darte una contestación e inducirte a hacer una parrillada de circuitos.
Mejor busca info o plantea una cuestión en el apartado de hardware.
Ya me contarás si el código actual hace algo.
Saludos.
34  International / Software / Re: Agradecería ayuda con código para medidor de humedad y 74HC595 2 digitos. on: September 13, 2014, 04:46:25 pm
Hola.
De momento, suponiendo, por ejemplo que tu termómetro va conectado al pin3, pon antes de la línea
OneWire oneWire(tempPin);
Esto:
const int tempPin=3;

Y en la línea
  int rT = (int)t;

supongo que será
  int rT = (int)h;

Saludos.
35  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 12, 2014, 06:14:07 pm
Bueno. Vamos con lo dicho en el post anterior. Me ha llevado un ratillo renombrar todo lo que había metido en el código como atlas a arduslave, pero al menos compila. Otra cosa será que funcione, pues no creas que tengo muy clara aún la función de todos los archivos que incluye el proyecto; pero creo que al menos es un comienzo.
He creado estos dos archivos en el proyecto:
ArduSlave.h
Code:
#ifndef __ArduSlave_H_
#define __ArduSlave_H_
#include <Arduino.h>
#include "Device.h"

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 unsigned arduslave_timeout=100;

class ArduSlave : public Device {
  public:
    ArduSlave():Device(){};
    void device_setup();
    void device_loop(Command cmd);   
};
#endif
ArduSlave.cpp
Code:
#include "AConfig.h"
#if(HAS_ARDUSLAVE)

#include "ArduSlave.h"
// #include "Settings.h"
//#include "Timer.h"
#include <Wire.h>

/*
Sketch to read a MS5803-14BA pressure sensor, written from scratch.
 Will output data to the serial console.
 
 Written by Walt Holm
 Initial revision 10 Oct 2013
 Rev 1 12 Oct 2013 -- Implements 2nd order temperature compensation
 */



const int DevAddress = ARDUSLAVE_I2CADDRESS;  // 7-bit I2C address of the MS5803

void ArduSlave::device_setup(){
      //Settings::capability_bitarray |= (1 << DEAPTH_CAPABLE);

      Serial.println("ArduSlave setup.");
      Wire.begin();
      delay(10);
}

void ArduSlave::device_loop(Command command){
      Wire.requestFrom(DevAddress, 32);
      data data_from_arduslave;

      unsigned int millis_start = millis();
      byte *pBdata = (byte *) &data_from_arduslave;
      for (int i=0; i<data_size; i++){
            if (Wire.available()){
                  pBdata[i]=Wire.read();
            }
            else {
                  if (((unsigned int)millis() - millis_start) > arduslave_timeout) {
                        Serial.println("log:Failed to read ArduSlave from I2C");
                        return;
                  }
            }
      }
      Serial.println();
      Serial.println(" DATA IN ARDUSLAVE ");
      Serial.println();
      Serial.print("Conductividad==> EC: ");
      Serial.print(data_from_arduslave.conductivity.ec);
      Serial.print(", TDS: ");
      Serial.print(data_from_arduslave.conductivity.tds);
      Serial.print(", SAL: ");
      Serial.print(data_from_arduslave.conductivity.sal);
      Serial.print(", SG: ");
      Serial.println(data_from_arduslave.conductivity.sg);
     
      Serial.print("pH==> ");
      Serial.println(data_from_arduslave.pH);
      Serial.print("DO==> ");
      Serial.println(data_from_arduslave.DO);
      Serial.print("ORP==> ");
      Serial.println(data_from_arduslave.ORP);
     
      // resto de datos de la estructura
      Serial.print("Temperatura==> ");
      Serial.println(data_from_arduslave.temperature);
     
      Serial.println();
      Serial.println(" DATA IN ARDUSLAVE END ");
      Serial.println();       
}
#endif

Además, te comento las modificaciones que he realizado en otros archivos (espero no dejarme ninguna):

Archivo openROV.ino. Al final de todos los #define, justo antes de la línea "Command cmd;"
Code:
#if(HAS_ARDUSLAVE)
  #include "ArduSlave.h"
  ArduSlave kit_sensores;
#endif

Archivo AConfig.h. Lo he puesto al final de la sección //After Market, bajo la línea #define MPU9150_EEPROM_START 2
Code:
#define HAS_ARDUSLAVE (1)
#define ARDUSLAVE_I2CADDRESS 0x77
He puesto la dirección i2c al tuntún. Puedes poner la que quieras, pero recuerda poner la misma en el esclavo.

Bueno. Espero que si no funciona al menos haga alguna cosa nueva.
Ya me dirás.
Saludos.
36  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.
37  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.
38  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.
39  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
40  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
}

41  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.
42  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?
43  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?
44  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*/
45  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.
Pages: 1 2 [3] 4 5 ... 38