Estoy intentando separar un const char * en dos variables, es decir, la cadena seria 26/30 y el resultado seria v1 = 26 y v2 =30.
int i;
// Mensaje con un chequeo correcto.
for (i = 0; i < buflen; i++)
{
Serial.write(buf[i]); // Los datos recibidos son guardados en el buffer
// y enviados por el puerto serie al ordenador
Serial.println("");
if(i <=1 )
v1 += buf[i];
else
v2 += buf[i];
}
Serial.println("");
Serial.println(v1);
Serial.println(v2);
y al imprimirlo no tiene nada que ver con el resultado:
gooo:
madremia!!! En la frente y no lo veja... gracias!
Pero si se supone que += concatena no??? o como puedo concatenarlos?
¿Qué tipo de variables son v1 y v2? ¿int, char* u objetos String?
el operador += suma, no concatena, salvo tal vez en el último caso (no lo he comprobado, creo que sí). De todas formas con una información más amplia de qué quieres realizar seguramente se te podrá dar una información más atinada a tu propósito.
Pues es un char*. Es el tipo de dato que se utiliza con los modulos rf.
Y lo que quiero es eso, pasar por radio frecuencia una serie de variables (temperatura, humedad rel, humedad del suelo etc) de un arduino a otro y trabajar con ellos en este ultimo.
Si pudieras poner el código completo, te podría dar mejores orientaciones. Lo que tienes que tener siempre presente es si lo que recibes es caracteres o valores. No es lo mismo char a=1 que char a='1' . Como te dijo AWOL, para convertir una cadena numérica a su valor entero equivalente, el bucle que debes realizar es:
int valor=0;
while (caracter_recibido!=CARACTER_LIMITADOR){
valor*=10;
valor+=(caracter_recibido - '0');
}
También podrías utilizar sprintf (para enviar las variables en una cadena) y sscanf (para escanear una cadena y cargar valores a variables).
Y si la librería permite enviar bytes, podrías enviar directamente una estructura con los datos sin convertir a cadena, con lo que disminuiría la cantidad de datos a enviar, y evitarías transformaciones a/de cadena.
El codigo no lo tengo delante, esta tarde si tengo 5 minutos lo pongo.
Utilizo sprintf para para crear la url (por llamarla de alguna forma), pero contando las variables que tengo que pasar son 9:
-tiempo riego zona1
-tiempo riego zona2
-higrometro zona1
-higrometro zona2
-humedad relativa
-temp. actual
-temp. maxima
-temp. minima
-% de agua en el deposito.
#include <VirtualWire.h>
//RF
char urlRF[100];
int humedadRel;
int temperaturaExt;
void setup(void)
{
Serial.begin(9600) ;
Wire.begin();
vw_set_ptt_inverted(true); // Requerido por el modulo RF
vw_setup(2000); // Velocidad de conexion bps
vw_set_tx_pin(12); // Pin en el que conectamos la patilla data
}
void rf( const char * variable){
const char *msg = variable;
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx(); // Esperamos a que termine de enviar el mensaje
delay(200); // Esperamos para enviar el siguiente mensaje
}
void loop(void){
sprintf(urlRF, "%d%d",temperaturaExt,humedadRel);
rf(urlRF);
}
Receptor:
#include <VirtualWire.h>
int humedadRel;
int temperaturaExt;
void setup()
{
Serial.begin(9600); // Configuramos la conexion serie con el ordenador
vw_set_ptt_inverted(true); // Requerido por el modulo RF
vw_setup(2000); // Velocidad de conexion bps
vw_set_rx_pin(11); // Pin en el que conectamos la patilla data del receptor
vw_rx_start(); // Arrancamos el receptor
}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen)) // Comprobamos si hemos recibido datos
{
int i;
// Mensaje con un chequeo correcto.
for (i = 0; i < buflen; i++)
{
Serial.write(buf[i]); // Los datos recibidos son guardados en el buffer
// y enviados por el puerto serie al ordenador
Serial.println("");
if(i <=1 )
temperaturaExt = (temperaturaExt * 10) + (buf[i] - '0');
else
humedadRel = (humedadRel * 10) + (buf[i] - '0');
}
Serial.println("");
Serial.println(temperaturaExt);
Serial.println(humedadRel);
}
}
Hola de nuevo.
Nunca había usado la librería virtualwire, pero veo que transmite/recibe datos binarios. La forma más "económica" de transmitir tus variables sería definir una estructura con los datos, asignar a un puntero uint8t la dirección de esa estructura, enviarla, y en el receptor el proceso contrario.
Más o menos así para el emisor:
// Definimos una estructura que va a contener todos los parámetros que queremos enviar.
struct variables
{
int tiempoRiegoZona1, tiempoRiegoZona2;
byte tempMax, tempMin, porcAguaDeposito;
// todas las demás variables que necesitemos
} varEnvio;
// obtenemos la dirección de memoria donde se guarda la estructura varEnvio, y la almacenamos en un puntero a uint8_t,
// que es el que necesita la función vwsend.
uint8_t *pVars = (uint8_t *)&varEnvio; // Hay que realizar un cast para evitar error de compilador.
// Como necesitaremos saber cuántos bytes enviar, guardamos el tamaño de la estructura en sizeVarEnvio.
uint8_t sizeVariables=sizeof(variables);
void loop() {
varEnvio.tiempoRiegoZona1=1000;
// Asignaríamos todas las variables, según lecturas o lo que sea...
vw_send(pVars,sizeVariables);
}
En el receptor haremos el proceso inverso:
// Una estructura igual a la de emisión para recibir los datos.
variables varRecepcion;
void loop() {
uint8_t sizeVariables=sizeof(variables); // Asignaremos el tamaño en loop, porque la función vw_get_message podría modificarla.
if (vw_get_message((uint8_t *)&varRecepcion, &sizeVariables)) // Recibimos directamente los datos a la estructura
}
Quedaría comprobar si efectivamente se ha recibido todo y bien, pero te evitas convertir en el emisor y luego en el receptor, y minimizas la cantidad de datos a enviar.
Ya me dirás si chuta.
Saludos.