Go Down

Topic: Lectura XBee Receptor para poder gobernar mi mountainboard (Read 4670 times) previous topic - next topic

Hola compañeros.

Tengo el siguiente código el cual esta todo ordenadito cuando lo veo en el monitor puerto serie.

Por un lado tengo primero un potenciometro con el cual gobernaré la intensidad de luz, el siguiente la potencia de un motor y el tercero lo usaré por que necesito controlar un servo para mecanicamente actuar como un freno, los pines 2 y 3 serán uno para encendido y apagado de luces y el otro para gobernar un claxón.

Todo esto para controlar mi mountainboard mediante XBee(joystich) a XBee(mountainboard).

Mi dura es la siguiente, ¿¿¿¿ como puedo leer esos datos ordenaditos en mi xbee receptor  ????? ya que creo que el problema de mandarlos al puerto serie ya lo tengo solucionado ya que cuando activos todas estas señales desde mi joystick me responden adecuadamente tanto analogicamente como digitalmente y así se me refleja en mi monitor serie.

La lectura que me sale es;    0       0       0       0       0  siempre que no actue sobre ningún pin de entrada. XD


const int xpin = A3;                  
const int ypin = A2;                
const int zpin = A1;                  
const int pushButton = 2;
const int pushButton3 = 3;

void setup()
{
 Serial.begin(19200);
}

void loop()
{
 {
 Serial.print(analogRead(xpin));
 
 Serial.print("\t");
 Serial.print(analogRead(ypin));
 
 Serial.print("\t");
 Serial.print(analogRead(zpin));
 
 Serial.print("\t");
 Serial.print(digitalRead(pushButton));
     
 Serial.print("\t");
 Serial.print(digitalRead(pushButton3));
 Serial.println();
 
 delay(100);  
}
}

Hola. Ahora no tengo tiempo para expkicar todo el proceso de comunicación, pero te recomiendo que eches una ojeada a los siguientes enlaces:

Configuración de Zigbee:

http://ladyada.net/make/xbee/arduino.html

Software de configuración de los chips Xbee:

http://www.digi.com/support/productdetail?pid=3352&osvid=0&type=utilities

Tengo intención de sacar un tutorial sobre la forma de comunicación Xbee de nuestro sistema de domótica. Cuando lo tenga te enviaré el enlace.
José Antonio Castillo Rodríguez
Responsable de diseño de producto
Functio & Ars S.L.
www.functionars.com

Hola Castillo.

Mi problema no es de configuracion de los modulos XBees ya k esta parte la apredi en su dia. Mis modulos comunican uno como coordinador y el otro como router end.

Envido datos analogicos por ejemplo para gobernar un servo y funcionan perfectamente o para encender un led.

Mi problema es cuando envio una cadela de datos ya k los consigo ver perfectamnte en mi consola variando los valores segun actuo en los potenciometro de entrada, el tema esta es en el receptor k no se como extraer dato x dato para redirigirlos y k actuen en consecuencia a su servo, motor, led..

He probado varias formas y por mas vueltas k le doy no consigo resultados.

Si pudieras aportare mas ayuda te lo agradeceria

De todas formas mirare y esturiare los enlaces k has agregado.

Saludos y gracias.

En nuestro sistema, lo que hacemos es enviar una cadena de datos, por ejemplo "aC"; con esto le indicamos a la placa que hemos definido como "a" que realice la instrucción correspondiente a la orden "C". Si enviamos la orden "bO" pues indica que a la placa "b" que realice la instrucción "O".

Para que cada placa haga se active cuando recibe "su encabezamiento" a,b...z lo que hacemos en leer la entrada serie, asignarle una variable para determinar si la placa esta activa o no. Entonces si recibe la llamada a su nombre mediante un if-then pasamos a hacer caso a la siguiente orden. Si no está activa, la siguiente orden la obviamos.

Hay que tener en cuenta que todas las placas con Xbee leen todas las instrucciones, por lo que el código selector ha de estar en la programación de la placa Arduino, haciendo ahí la selección de qué ordenes son a las que tiene que hacer caso y a cuales no.

Adjunto un ejemplo probado:

Code: [Select]
* PROGRAMA DE PRUEBAS PARA VERIFICACIÓN DEL COMPORTAMIENTO DE LOS PINES
Programa realizado por José Antonio Castillo Rodríguez:
+ Pines actuables son todos (0-13 digitales; 0-5 analógicos)
+ "@" selecciona la placa como activa para ACTIVAR-ON un pin
+ "#" selecciona la placa como activa para APAGAR-OFF un pin
+ "2", "3",..."a", "b", "c", "d" realiza la acción sobre el pin digital del mismo número, siendo a=10, b=11, c=12, d=13
+ "&" selecciona la placa como activa para leer un pin analógico
+ "0", "1", "2",..."5" numeración de los pines analógicos
+
+ OTRO VALOR -> desactiva todos los pines
+
+ el pin de lectura del cambio de estado manual esta definido por variable (remotoPin)
+
+ Como prueba, se va a enviar como respuesta una señal del tipo "a2ON", esto es:
+ "placaActiva"+"nº de pin"+"estado del pin" para que lo lea el sistema central
+
*/

// VARIABLE DE SELECCIÓN DE PLACA
int inByte = 0;    // almacena la lectura del puerto serie
int selecPlacaOn = '@';    // CTE-valor ante el CUAL se activa la placa en modo escucha para activar los pines
int selecPlacaOff = '#';    // CTE-valor ante el CUAL se activa la placa en modo escucha para apagar los pines
int selecLecturaOn = '&';    // CTE-valor ante el CUAL se activa la placa para lectura de sensor analógico
boolean placaActivaOn = false;    // indica si la placa está en modo escucha o no para modo encender
boolean placaActivaOff = false;    // indica si la placa está en modo escucha o no para modo encender
boolean placaLecturaOn = false;    // indica si la placa está en modo escucha o no para modo lectura de sensor
int sensorValor = 0; // Almacena el valor leido en el pin del sensor

void setup() {
 // initialize serial communication:
 Serial.begin(9600);
 // inicialización de los pines digitales para escritura
 for (int thisPin = 2; thisPin < 14; thisPin++) {
       pinMode(thisPin, OUTPUT);
     }
}

void loop() {
 // lectura de la señal serie
 if (Serial.available() > 0) {
   int inByte = Serial.read();
   if (placaActivaOn == true) {    // si la placa está en modo activo pasa a actuar dependiendo de la lectura del valor de inByte
     switch (inByte) {
     // encendido del pin 2
     case '2':    
       digitalWrite(2, HIGH);
     // hay que enviar por serie el código
       Serial.print(selecPlacaOn, BYTE);
       Serial.print('2', BYTE);
       Serial.print('O', BYTE);
       Serial.print('N', BYTE);
       Serial.print(",");
       break;
     // encendido del pin 3
     case '3':    
       digitalWrite(3, HIGH);
     // hay que enviar por serie el código
       Serial.print(selecPlacaOn, BYTE);
       Serial.print('3', BYTE);
       Serial.print('O', BYTE);
       Serial.print('N', BYTE);
       Serial.print(",");
       break;
       }
     }
   }
   
   if (placaActivaOff == true) {    // si la placa está en modo activo pasa a actuar dependiendo de la lectura del valor de inByte
     switch (inByte) {
     // encendido del pin 2
     case '2':    
       digitalWrite(2, LOW);
     // hay que enviar por serie el código
       Serial.print(selecPlacaOff, BYTE);
       Serial.print('2', BYTE);
       Serial.print('O', BYTE);
       Serial.print('F', BYTE);
       Serial.print('F', BYTE);
       Serial.print(",");
       break;
     // encendido del pin 3
     case '3':    
       digitalWrite(3, LOW);
     // hay que enviar por serie el código
       Serial.print(selecPlacaOff, BYTE);
       Serial.print('3', BYTE);
       Serial.print('O', BYTE);
       Serial.print('F', BYTE);
       Serial.print('F', BYTE);
       Serial.print(",");
       break;

     default: //cualquier otro valor leido apaga todo
       // corta la alimentación de los pines 2 a 4 -> relés sin alimentación
       for (int thisPin = 2; thisPin < 14; thisPin++) {
       digitalWrite(thisPin, LOW);
       // hay que enviar por serie el código
       Serial.print(selecPlacaOff, BYTE);
       Serial.print('a', BYTE);
       Serial.print('l', BYTE);
       Serial.print('l', BYTE);
       Serial.print('O', BYTE);
       Serial.print('F', BYTE);
       Serial.print('F', BYTE);
       Serial.print(",");
       }
     }
   }
   

   if (placaLecturaOn == true) {    // si la placa está en modo activo pasa a actuar dependiendo de la lectura del valor de inByte
     switch (inByte) {
     //lectura del pin analógico 0
     case '0':    
       sensorValor = analogRead(0);
     // hay que enviar por serie el código
       Serial.print(selecLecturaOn, BYTE);
       Serial.print('0', BYTE);
       Serial.print('/', BYTE);
       Serial.print(sensorValor, DEC);
       Serial.print(",");
       sensorValor = 0;
       break;
     // encendido del pin 3
     //lectura del pin analógico 1
     case '1':    
       sensorValor = analogRead(1);
     // hay que enviar por serie el código
       Serial.print(selecLecturaOn, BYTE);
       Serial.print('1', BYTE);
       Serial.print('/', BYTE);
       Serial.print(sensorValor, DEC);
       Serial.print(",");
       sensorValor = 0;
       break;
     //lectura del pin analógico 2
     case '2':    
       sensorValor = analogRead(2);
     // hay que enviar por serie el código
       Serial.print(selecLecturaOn, BYTE);
       Serial.print('2', BYTE);
       Serial.print('/', BYTE);
       Serial.print(sensorValor, DEC);
       Serial.print(",");
       sensorValor = 0;
       break;

     default: //cualquier da lectura errónea
       // hay que enviar por serie el código
       Serial.print(selecLecturaOn, BYTE);
       Serial.print('e', BYTE);
       Serial.print('r', BYTE);
       Serial.print('r', BYTE);
       Serial.print(",");
     }
   }

   // caso que la placa esté en modo activo, se vuelve a modo escucha tras
   // haber ejecutado la orden correspondiente
   if (placaActivaOn == true) {
     placaActivaOn = false;
   }
   
   if (placaActivaOff == true) {
     placaActivaOff = false;
   }

   if (placaLecturaOn == true) {
     placaLecturaOn = false;
   }
   
   //******** SELECCIÓN DE LA PLACA PARA ACTIVACIÓN DE PIN ***************************
   //*********************************************************************
   // si la variable inByte se corresponde con la letra de la placa (la asignada a la variable selecPlacaOn en este caso)
   // la placa se pone en modo activo
   if (inByte == selecPlacaOn) {
     placaActivaOn = true;
   }
   
   //******** SELECCIÓN DE LA PLACA PARA APAGADO DE PIN ***************************
   //*********************************************************************
   // si la variable inByte se corresponde con la letra de la placa (la asignada a la variable selecPlacaOff en este caso)
   // la placa se pone en modo activo
   if (inByte == selecPlacaOff) {
     placaActivaOff = true;
   }

   //******** SELECCIÓN DE LA PLACA PARA LECTURA DE PIN ANALÓGICO *******************
   //*********************************************************************
   // si la variable inByte se corresponde con la letra de la placa (la asignada a la variable selecLecturaOn en este caso)
   // la placa se pone en modo activo
   if (inByte == selecLecturaOn) {
     placaLecturaOn = true;
   }
   
 }
}


NOTA: he eliminado las acciones a partir de los pines núm 2 para que cupiese todo el código.

Lamento que el ejemplo sea un poco largo, pero éste está probado que funciona. Aquí, el primer caracter indica qué tipo de acción debe hacer el pin del número que se indica a continuación. El segundo caracter es el pin sobre el que se actúa. Si programases varias placas arduino con este código, todas harían lo mismo al mismo tiempo. Para la selección de placa lo único que tienes que hacer es cambiar el primer caracter por uno específico para cada placa.

Espero haber entendido esta vez el sentido de tu consulta. Un saludo.
José Antonio Castillo Rodríguez
Responsable de diseño de producto
Functio & Ars S.L.
www.functionars.com

Que tal Castillo y compania.

Lo que yo quiero enviar es varios datos a la vez de un arduino a otro con xbee, no quiero enviar una serie de ordendes para varios arduinos y en función de la orden a la que va destinada que obedezca el ejecutor de esa orden, eso no es lo que yo pretendo.

Yo solo quiero enviar tres datos analogicos y tres digitales desde un arduino y que otro lo reciba y ejecute sobre dos servos y un motor los valores mandados así como los estados de los tres datos 0 o 1 a los pines digitales.

Yo me he confeccionado este codigo que adjunto en la foto y como ves en la consola de la izquierda me lee correctamente, mi problema es que no logro leer en el receptor esos valores para dar ordenes a mis servos, motor y leds.

Alguna sujerencia?

Saludos.

Creo que ahora comprendo lo que pretendes. No usas el ordenador para enviar las órdenes, usas una placa Arduino. El problema, por lo que sé es que para poder usar un Arduino como "modem" emisor de órdenes hay que quitar el chip ATMega, con lo cual no puedes programar nada, pues la placa Arduino se convierte en una simple pasarela.

De todas formas, ahora que lo pienso, nosotros leemos los datos que nos envían las placas sobre los valores de los sensores... puede ser que te pueda proponer una solución. Dame un poco de tiempo y te comento algo (casi seguro que te puedo enviar una solución pues un error que teníamos se debía a que una instrucción con el valor de un sensor "interfería" en las señales de los actuadores por ser demasiado parecida.
José Antonio Castillo Rodríguez
Responsable de diseño de producto
Functio & Ars S.L.
www.functionars.com

Hola Castillo y demás compañeros.

Respecto al primer punto que comentas efectivamente el chip se quita, pero tan solo para usar la placa arduino como pasarela para programar los modulos Xbee como coordinador y router y una vez que están programadas mediante el software X-CTU, se insertan otra vez el chip en su zocalo y se puede usar de nuevo  como placa arduino para el uso al que esta destinada.

Efectivamente lo que pretendo es enviar desde un arduino con Xbee y recepcionar con otro arduino con Xbee y lo he conseguido mediante estos codigos que os adjunto aquí:

COORDINADOR

int val = 0;
byte mapVal = 0;
int potPin = 0;

void setup()
{
  Serial.begin(9600);
  pinMode(potPin, INPUT);
}

void loop()
{
  val = analogRead(potPin);
  mapVal = map(val,0,1023,0,179);
  Serial.write(mapVal);
  delay(2);
}


ROUTER END



#include <Servo.h>

Servo scottServo;  // create servo object to control a servo

int servoPin = 9;  // analog pin used to connect the potentiometer

int servoValue = 0;    // variable to read the value from the analog pin

void setup()
{
  Serial.begin(9600);
  scottServo.attach(9);  // attaches the servo on pin 9 to the servo object
}
    servoValue = Serial.read();
    scottServo.write(servoValue);
    delay(2);
  }
}

Hasta aquí todo bién, el problema es que si por ejemplo le declaro una variable digital en el emisor para que lo recepcione el receptor, cuando lo lee y ejecute la orden como salida, para que actue algún contro como encender las luces de mi mountainboard, es un carácter del codigo ascill, vale pues aquí esta el problema ya que la lectura del potenciometro del emisor es de 0 a 255 y cada uno de esos valores corresponde a cada uno de los codigos ascill y siempre en algún momento coincide con el valor digital de otro actuador analógico o con el valor que hayamos declarado en la variable digital interfiriendo las lecturas.

Por esto yo quiero separar todas las lecturas analogicas y digitales en el emisor mandarlas en un paquete y recepcionarlas en el receptor desgranar ese paquete separando esas lecturas y mandarlas cada una a su pin para que cada actuador (servofreno, motor, luces, claxon...) no se mezclen y se ejecuten de manera correcta.

Si alquien tiene alguna sujerencia se lo agradezco.

:smiley-mr-green:

Aquí os pongo unas fotos de mi proyecto que lo tengo bastante abanzado.

Inicialmente controle mediante bluetooth desde mi teléfono con android y con el programa MOBOT BT Car, el cual enviaba algún carácter ascill y mi placa arduino con el modulo bluetoothh acoplado recepcionaba las lecturas ascill y ejecutaba las ordenes, incrementando y decrementando la pontencia de motor mediante pulso, pulsado mas o menos veces según quería ir mas rapido o despacio o pulsando continuamente para ejecutar el servofreno y parar el rodaje.

Pero esta manera totalmente digital no era operativa ya que lo suyo es mediante un gatillo de aceleración y otro de frenado, es decir con señales analogicas es mas seguro, divertido y real el manejo del mountainboar, ya que tienes la sensación de todo el control en el tacto del dedo ya que si presionas mas o menos tanto para frenar como para acelerar.

Por eso voy durante tiempo estudiando como mandar esas señales de un arduino a otro.

Admito sujerencias, siempre es bueno escucar a la gente.

Cuando tenga tiempo os adjunto mas fotos con detalle.

Saludotes.

yOPERO



Hasta aquí todo bién, el problema es que si por ejemplo le declaro una variable digital en el emisor para que lo recepcione el receptor, cuando lo lee y ejecute la orden como salida, para que actue algún contro como encender las luces de mi mountainboard, es un carácter del codigo ascill, vale pues aquí esta el problema ya que la lectura del potenciometro del emisor es de 0 a 255 y cada uno de esos valores corresponde a cada uno de los codigos ascill y siempre en algún momento coincide con el valor digital de otro actuador analógico o con el valor que hayamos declarado en la variable digital interfiriendo las lecturas.



Podrías poner un ejemplo de la interferencia con valores  de al menos dos comando que coincidan. la verdad no visualizo..


Engineering is the art of
making what you want from
things you can get.

     

[SOLUCIONADO]

Hola Yopero.

Mira en este codigo he añadido las lineas de buzzer, para cuando pulso en el emiror sobre el pin 5, envíe al receptor la orden para que la ejecute sobre también el pin 5.

if(digitalRead(botonbuzzer)== HIGH) {
    Serial.print('D'); }
 
Como ves le e asignado al botonBuzzer el carácter D y cuando actuo sobre el servo como va de 0 a 255 y corresponden a todos los caracteres ascill cuando coincide con la D me actua sobre BotonBuzzer

aquí te dejo el codigo.

Por cierto si sabes como enviar la orden para dos servos....?

COORDINADOR

int val = 0;
byte mapVal = 0;
int potPin = 0;
int botonbuzzer = 5;

void setup()
{
  Serial.begin(19200);
  pinMode(potPin, INPUT);
  pinMode(botonbuzzer, INPUT);
}

void loop()
{
  val = analogRead(potPin);{
  mapVal = map(val,0,1023,0,180);
  Serial.write(mapVal);
  delay(2);
}
{
  if(digitalRead(botonbuzzer)== HIGH) {
    Serial.print('D'); }
   
}
}


ROUTER END

#include <Servo.h>

Servo scottServo;  // create servo object to control a servo
int servoPin = 9;  // analog pin used to connect the potentiometer
int servoValue = 0;    // variable to read the value from the analog pin
int buzzer = 5;

void setup()
{
  Serial.begin(19200);
  scottServo.attach(9);
  pinMode(buzzer,OUTPUT);
}

void loop()
{
  if(Serial.available()> 0)

    servoValue = Serial.read();
    scottServo.write(servoValue);
   
   
    if(Serial.read()== 'D') {
      digitalWrite(buzzer,HIGH);
      delay(10);
      digitalWrite(buzzer,LOW); }
   
  }

yOPERO

#10
Nov 10, 2012, 12:35 pm Last Edit: Nov 10, 2012, 12:41 pm by yOPERO Reason: 1
Creo que el problema esta en la forma en la que envías y recibes datos.

Tienes que crearte un mini protocolo con un carácter de inicio y fin

eg:
Desde el emisor:
Si quieres que el buzzer suene por 2 segundos  debes enviar el comando para el buzzer "B" el comando de high "1" y el tiempo "2" quedando la cadena en B12

Si quieres un motor tendrás que enviar el comando para el motor "M" luego quizás el valor como 255 quedando la cadena en M255

Tu protocolo tiene que ser siempre de la misma longitud:
B120 //anado un 0 para hacerlo de 4 caracteres
M255 //no hay cambios

Para hacerlo aun mas estable añades un carácter de inicio  "<" y fin ">"

Tu protocolo de envió quedaría  "<XNNN>" donde X es una letra y N un numero.

En el receptor:
Tienes que desgranar el protocolo
si recibo "<" y recibo "X " y recibo "N" y "N" y "N" y ">" almaceno XNNN en un array luego en función de este array mandas ordenes:

if array[0] = B y array[1]= 1
{
pinbuzeer = high;
delay(array[2]);
}
Esa es la idea general.
Trabaja en ello y si quieres y necesitas mas ayuda el fin de semana que viene tendré mas tiempo que este.(hacemos un hackaton virtual)


 
Engineering is the art of
making what you want from
things you can get.

     

[SOLUCIONADO]

Hola yOPERO.

Después de algunos días desconectado debido al currillo, hoy por fin me puedo dejar ver por aquí para leer toas las cosas interesantes que hay por aqui, esto es como cuando llevabas varios días sin ir a jugar al futbolin por que tenias examenes, jijiji.

YOPERO así como lo cuentas lo entiendo y lo comprendo perfectamente lo esplicado en el post anterior, el problema es que intentado crear algún protocolo, perdiendome debido a mi poca experiencia con este lenguaje de programación arduino.

Te estaria super agradecido si así como me transmites podemos hacer un hackaton virtual este finde, ya que estoy deseando seguir aprendiendo y por supuesto llegar a terminar mi proyecto.

Voy a ver si abanzo algo y te cuento.

Abrazotes compis... :smiley-mr-green:

yOPERO

Debido a la huelga he tenido un hueco, he escrito el código de abajo para el receptor
El emisor tendrá que enviar algo  como:
Code: [Select]
Serial.print('/')//El byte de incio de  la trama
Serial.print(1)//el servo a controlar
Serial.print(150)//el angulo del servo


Y este el codigo del receptor:
Code: [Select]
/*! \mainpage Mountain_Board Index Page
*
* \section intro_sec Descripcion
*
  Mountain_Board_rx.ino v1.0
  \n Leemos el puerto Serie y esperamos por 3 bytes. Comprobamos si el primer byte es el "Byte_Inicio" si asi fuese almacenamos los dos siguientes bytes como
  "servo" y "pos" usando como intermediario el array  "userInput[2]".
  \n\n eg comando para mover servo1 180 grados ==  /1180.
  \n eg comando para mover servo2   5 grados == /25.
*/

/** Incluimos la libreria  <Servo.h>. */
#include <Servo.h>
/**create servo object to control a servo*/
Servo servo1;

/**create servo object to control a servo*/
Servo servo2;

/*--Variables y constantes para manejar los bytes que recibimos---*/
/**Valor en decimal de nuestro Byte_Inicio*/
#define Byte_Incio 47 //Valor en decimal de nuestro Byte_Inicio(47 = '/')

/**Almacena primer Byte*/
int first_Byte;

/**Almacena el servo*/
int servo;

/**Almacena la posicion*/
int pos;

void setup()
{
  Serial.begin(9600);
  servo1.attach(9);  // attaches the servo on pin 9 to the servo object
}

void loop()
{
  Leer_Serial();
  Switch_Servo();
  //DEBUG();
  delay(10);//10-20ms
}

/** \brief Leer datos recibidos del Serial */
void Leer_Serial(){
  /**
    \details Esperamos por 3 bytes y comprueba si el primer byte es el
    Byte_Inicio, luego almacena los dos siguientes bytes.
  */
  if (Serial.available() > 2)//Esperar a tener por lo menos 3 bytes
{
    // Leer el primer byte
    first_Byte = Serial.read();
    // Si es realmente el first_Byte (47) ... '/'
    if (first_Byte == Byte_Incio)
      {
      int i;
      int  userInput[2];// ... entonces almacenar los 2 siguientes bytes
      for (i=0;i<2;i++) {
        userInput[i] = Serial.read();
      }
        // Primer byte =  que servo a mover
        servo = userInput[0];
        // Segundo byte = a que posicion
        pos = userInput[1];
       }
   }

}

/** \brief Para manejar mas de un servo si fuese necesario*/
void Switch_Servo(){
  /**
    \details Para manejar mas de un servo si fuese necesario.
    \n Escoge que servo mover segun lo recibido en leer_serial().
  */
   
  switch (servo) {
    case 1:
      servo1.write(pos);    // mover servo1 a 'pos'
      break;
    case 2:
      servo2.write(pos);
      break;
    default:
      break;
      } 
}
/**\brief DEBUGGING.....*/
void DEBUG(){
  Serial.print(first_Byte);//DEBUG
  Serial.print(servo);//DEBUG
  Serial.print(pos);//DEBUG
}


Con esto ya puedes adaptar el código a tus necesidades.
Engineering is the art of
making what you want from
things you can get.

     

[SOLUCIONADO]

yOPERO

#13
Nov 15, 2012, 12:38 pm Last Edit: Nov 15, 2012, 12:42 pm by yOPERO Reason: 1
Dado que usamos comunicaciones inalámbricas
//ToDo:  error checking(enviar datos normal e inverso)
Engineering is the art of
making what you want from
things you can get.

     

[SOLUCIONADO]

Hola yOPERO.

Este fin de semana me pongo con este  código el cual me pondrá a estudiar para ver que puedo hacer e ir dándole forma.

Un saludo y gracias.

Go Up