Show Posts
Pages: [1] 2 3 ... 37
1  International / Software / Re: Conflicto con librerias.... on: September 16, 2014, 04:31:12 pm
No sé qué arduino estás utilizando, ni qué timers tendrás en uso para controlar el motor, pero puedes intentar modificar con un editor de texto el archivo VirtualWire_Config.h de la librería para indicar que utilice un timer distinto.
Para ello ve a la línea 30 de dicho fichero y descoméntala (quita los // del principio):

#define VW_TIMER_INDEX 1

y prueba a cambiar el 1 por otro número de timer (si no utilizas millis en tu programa, puedes intentar con 0).
A ver si hay suerte y suena la flauta.
Saludos.

2  International / Proyectos / Re: Proyecto: añadir sensores a un robot submarino on: September 15, 2014, 05:40:06 pm
Ufff. Acabas de abrir otro melón bastante grande  smiley-eek-blue. Hay bastante que escrutar.
Pero habrá que ir paso a paso, ¿no? Primero habrá que ver si los datos llegan al ordenador, que no estoy muy seguro de si hemos implementado bien el device.
3  International / Software / Re: Conflicto con librerias.... on: September 15, 2014, 05:24:32 pm
Sí. Los timers son unos contadores por hardware. Por explicarlo coloquialmente, se programa su divisor de reloj, el número en el que alcanzará el final de cuenta y la función que realizará entre varias posibles (conmutar un PWM, lanzar una interrupción...).
Ambas librerías, por lo poco que he visto, están tirando de timers, así que probablemente cuando estableces la velocidad de un motor, estás modificando los parámetros de un timer que está usando la librería virtualwire.
4  International / Software / Re: Conflicto con librerias.... on: September 15, 2014, 04:47:48 pm
¿Podría estar en que compartan un timer?
5  International / Español / Re: Pulsador de acceso universal on: September 15, 2014, 09:21:52 am
El propio loop, como su nombre indica, es un bucle. Lo único que tienes que hacer es llevar la cuenta de pulsaciones. Prueba a ver si esto hace algo. He utilizado un contador para que te resulte más claro, teniendo en cuenta que la longitud de todos los códigos es 6. En el caso de morse, como te expliqué, hay longitud variable de códigos, con lo que habría que almacenar el valor de una forma un poco distinta.

Code:
const int bot1=2; // Pulsador en PIN2
boolean estadoUltimo  = 0;   //Estado ultimo pulsador

unsigned long Tinicio;         //Momento en que se pulsa el pulsador

byte cod=0;      // valor del byte que se está recibiendo
byte recibidos=0; // bits recibidos hasta el momento

void setup()
{
  pinMode(bot1,INPUT);
  Serial.begin(9600);
}
void loop()
{
      boolean estadoActual=digitalRead(bot1);
      if(estadoActual!=estadoUltimo){
            estadoUltimo=estadoActual;
            if (estadoActual==HIGH){     
                  Tinicio=millis();
            } else {
                  unsigned long Tpulsacion = millis() - Tinicio;
                  if (Tpulsacion>20){      // detectada pulsación no considerada rebote
                        cod <<= 1;      // desplazamos un bit a la izquierda el valor que tenemos hasta ahora
                        recibidos++;
                        if (Tpulsacion > 200){
                              cod|=B00000001;      // si la duración>200 convertimos el bit recibido en 1
                        }
                        if (recibidos>=6) {      // si el bit 6 está a 1 es que ha habido 6 desplazamientos
                              Serial.print("RECIBIDO CODIGO ");
                              Serial.print(cod, HEX);
                              recibidos = 0;
                              cod = 0; // reiniciamos valor.
                        }
                  }
            }
      }
}

Saludos.
6  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?
7  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
8  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.
9  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.
10  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.
11  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.
12  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.
13  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.
14  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
15  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
}

Pages: [1] 2 3 ... 37