Show Posts
Pages: [1] 2 3 4
1  International / Español / Re: Construir maqueta domótica controlada por internet on: June 22, 2011, 03:33:36 am
Héchale un vistazo al siguiente link:

http://ahorcandoeltiempo.blogspot.com/2006/09/version-11-control-linksys-arduino.html

En el te explica como conectar un router wrt54gl con arduino por puerto serie. Esto tiene muchas ventajas como por ejemplo te ahorras la shield ethernet, dotas a arduino de conectividad ethernet y wireless, si tienes mucho procesamiento puedes hacerlo en el router, ...

En el link te explica como conectarlo a un wrt54gl, pero también se podría hacer a cualquier router que acepte el firmware dd-wrt, como por ejemplo una fonera (que tiene casi las mismas dimensiones que un arduino uno).
2  International / Español / Re: Enviar datos de un arduino a otro on: June 08, 2011, 06:58:47 am
la parte de enviar creo que resulta bastante sencilla serial.print y lkuego entre parentesis cada valor que quiera enviar, pero el tema es a la hora de recibirlos en la otra placa si debo almacenar cada uno en una variable diferente y de ser asi como voi a diferenciarlos cuando llegen...

Sí, tienes que almacenarlos y luego darle el trato que quieras a esos valores, como por ejemplo ir displayándolos cada cierto tiempo.

Lo que debes hacer si vas a enviar varios valores es crear un protocolo de comunicación entre los 2 arduinos que se adapte a tus necesidades.

Un ejemplo de comunicación entre los dos arduinos puede ser:

-- placa2 -> placa1: Quiero la lectura del sensor x
-- placa1 -> placa2: La lectura es y

de este modo la placa2 inicia la comunicación haciendo una petición del valor del sensor x a la placa1, la cuál responderá con el valor de x.

Otro ejemplo de comunicación podría ser el siguiente:

-- placa1 -> placa2: El sensor x vale y

de este modo la placa2 puede recibir un comando en cualquier momento, con lo cuál tenemos siempre que estar leyendo del puerto serie por si nos llegan nuevos datos.

Ahora te voy a dar una posible implementación del segundo ejemplo:

Para la placa1:
Code:
int interruptor1 = 3; // Interruptor 1
int interruptor2 = 4; // Interruptor 2

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

/* Función para leer el estado de un interruptor, devuelve 1
 * si está activado y 0 si está desactivado */
byte leerEstadoInterruptor(int numInterruptor) {
  int aux;
  switch (numInterruptor) {
    case 1:
      aux = digitalRead(interruptor1);
      break;
    case 2:
      aux = digitalRead(interruptor2);
      break;
    default:;
  }
  if (aux == HIGH) {
    return 1;
  }
  return 0;
}

/* Función para enviar la lectura del sensor. Se envía primero
 * un byte para indicar de que sensor se trata y después el
 * valor del mismo */
void enviarLectura(int numSensor) {
  Serial.print(numSensor, BYTE); //Se envía en formato BYTE para que no haga
                                //la conversión a ASCII.
  Serial.print(leerEstadoInterruptor(numSensor)); //Enviamos el valor
                                                  //del sensor
}

void loop() {
 
  enviarLectura(1);
  enviarLectura(2);
  delay(1000);
 
}

Para la placa2:
Code:
int estadoInterruptor1;
int estadoInterruptor2;
int interruptorRecibido;

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

void recibirLectura() {
  if (Serial.available() > 0) {
    interruptorRecibido = Serial.read();
    switch (interruptorRecibido) {
      case 1:
        estadoInterruptor1 = Serial.read();
        break;
      case 2:
        estadoInterruptor2 = Serial.read();
        break;
      default:;
    }
  }
}

void loop() {
  recibirLectura();
}

Este ejemplo lo que hace es enviar cada 1 segundo el estado de 2 interruptores colocados en los pines 3 y 4. Para diferenciar de que interruptor se trata lo que hace es primero enviar un byte que indica el interruptor del que se trata y después envía otro byte con el estado del mismo.

Espero que te sirva de ayuda.

Saludos chato_sat
3  International / Español / Re: Enviar datos de un arduino a otro on: June 08, 2011, 03:46:46 am
La funcion Serial.available() devuelve el número de caracteres que hay en el puerto serie. Normalmente se hace lo siguiente:

if (Serial.available() > 0) { // Si hay datos en el puerto serie
  byte leido = Serial.read(); // Leemos un byte y lo almacenamos en leido.
}

La función read no tiene parámetros y devuelve un byte que es el byte leído. Con lo cuál si quieres leer más de un byte lo deberías hacer de la siguiente forma:

byte leido;
while (Serial.available() > 0) {
  leido = Serial.read();
  //Tratamos el byte leido, ya que al volver hacer la lectura este se nos machacará
}

Héchale un vistazo a http://arduino.cc/en/Serial/Read en el ejemplo que hay se ve muy claro el uso de estas funciones.

Saludos chato_sat.
4  International / Español / Re: arduino uno on: June 02, 2011, 04:28:42 am
A mí también me sucedía el mismo problema, la solución fue detener la búsqueda automática de drivers y decirle manualmente donde tiene que buscar los drivers. Después le dices que busque en arduino->drivers (tiene que ser ese directorio, porque si te metes en el de arduino->drivers->FTDI USB Drivers no los encuentra).

Saludos chato_sat.
5  International / Español / Re: Problema con buffer serial on: May 26, 2011, 06:48:39 am
Creo haber encontrado el problema (estos son los problemas tontos que tenemos y nos hacen perder mucho tiempo smiley-lol). Mirando la consola de arduino he visto al lado de la velocidad de transmisión un desplegable con varias opciones, yo lo tengo en "no line ending" y funciona perfecto, he probado en todas las otras opciones y como manda el retorno de carro y algunas opciones más, me pasa lo mismo que a tí. Así que prueba cambiando la opción a "no line ending" y me cuentas que tal.

Saludos chato_sat.
6  International / Español / Re: Problema con buffer serial on: May 26, 2011, 06:12:13 am
Hola reex74.

He ejecutado el código que has puesto en mi arduino duemilanove y he obtenido los siguientes resultados:

Introduzco 123456
Code:
setup
El caracter 1 de X es 1
El caracter 2 de X es 2
El caracter 3 de X es 3
X_buffer =123
X_pos =123
El caracter 1 de Y es 4
El caracter 2 de Y es 5
El caracter 3 de Y es 6
Y_buffer =456
Y_pos =456
fin

A mí no se me ejecutado 2 veces se me queda ahí esperando que se introduzca otro valor y al introducirlo me da lo siguiente:

Después de 123456 introduzco 654321
Code:
setup
El caracter 1 de X es 1
El caracter 2 de X es 2
El caracter 3 de X es 3
X_buffer =123
X_pos =123
El caracter 1 de Y es 4
El caracter 2 de Y es 5
El caracter 3 de Y es 6
Y_buffer =456
Y_pos =456
fin
El caracter 1 de X es 6
El caracter 2 de X es 5
El caracter 3 de X es 4
X_buffer =654456
X_pos =-904
El caracter 1 de Y es 3
El caracter 2 de Y es 2
El caracter 3 de Y es 1
Y_buffer =321
Y_pos =321
fin

Como se puede observar la variable X_buffer =654456 y debería de ser 654, eso es porque imprimes X_buffer y busca el valor \0 para terminar y al no estar bien situado te la imprime mal, para solucionar el problema debes de poner \0 al final del array y el código quedaría así:
Code:
#include <stdlib.h>   
char X_buffer[4];
char Y_buffer[4];
int received;
int i=0;
int j=0;
int X_pos=0;
int Y_pos=0;

void setup()
{
    Serial.begin(9600);
    received = 0;
    X_buffer[3] = '\0';
    Y_buffer[3] = '\0';
    Serial.println("setup");
}
void loop()
{
    if (Serial.available())
      {
        delay(100);
// Get x cord
  for(i=0; i<3; i++)
    {
    X_buffer[i] = Serial.read();
            Serial.print("El caracter ");
            Serial.print(i+1);
            Serial.print(" de X es ");
            Serial.println(X_buffer[i]);
    }   
        X_pos = atoi(X_buffer);
        Serial.print("X_buffer =");
        Serial.println(X_buffer);
        Serial.print("X_pos =");
        Serial.println(X_pos,DEC);       
  // Get y cord
  for(j=0; j<3; j++)
    {
    Y_buffer[j] = Serial.read();
            Serial.print("El caracter ");
            Serial.print(j+1);
            Serial.print(" de Y es ");
            Serial.println(Y_buffer[j]);
    }        
Y_pos = atoi(Y_buffer);
        Serial.print("Y_buffer =");
        Serial.println(Y_buffer);
        Serial.print("Y_pos =");
        Serial.println(Y_pos,DEC);
        Serial.println("fin");   
      }
//Serial.print("X_buffer =");
//Serial.println(X_buffer);
//Serial.print("X_pos =");
//Serial.println(X_pos,DEC);
received = 0;
//Serial.println("Espero 1000");
delay(1000);
}

No sé si al hacer esto se solucionará el problema de repetirse el bucle, pero prueba a ver que tal, ya que al producirse este error no sé si puede afectar a algo más. Si sigue repitiéndose prueba a hacer if (Serial.available() > 0) a ver si se soluciona.

Saludos chato_sat.




7  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 17, 2011, 07:00:49 pm
Con la instrucción Serial.begin(int baud) iniciamos la comunicación por el puerto serie. Seria esta instrucción recibe un parámetro que es un número que indica la velocidad de transmisión de los datos. Normalmente se utiliza 9600 (esto si quieres que te diga la verdad no se porque pero supongo que será porque alguna de las placas de arduino es la velocidad máxima a la que se puede conectar). Yo he llegado a utilizar hasta 115200 baudios que es como se mide.

La instrucción Serial.println y Serial.print son instrucciones que se dan al arduino para que envíe datos por el puerto serie, el cual nosotros recibimos con nuestra consola y podemos visualizarlo en el ordenar. Serial.print y Serial.println pueden recibir varios parámetros según lo que queramos imprimir, p.e. con Serial.println("Comenzamos el programa") estoy imprimiendo una cadena de caracteres y con Serial.println(myVariable); estoy imprimiendo un número que es el valor que tiene nuestra variable. La diferencia que hay entre print y println es que este último imprime un retorno de carro.

Lo del porque se incrementa myVariable en 10 es porque me has pedido que te pusiera un ejemplo y no se me ha ocurrido otra cosa smiley-lol. Así con este ejemplo veías como se incrementaba una variable y te haces una idea.

Este ejemplo no tiene ningún uso práctico, ya que lo único que hace es imprimir líneas del tipo:

Has pulsado el botón
myVariable vale: 0
Has pulsado el botón
myVariable vale: 10
Has pulsado el botón
myVariable vale: 20
Has pulsado el botón
myVariable vale: 30

y así sucesivamente con cada pulsación del botón.

De igual forma no te asustes todo esto está explicado mucho mejor de lo que lo hago yo (soy un mal didacta smiley-lol) en los pdf's. Allí aprenderás sobre las funciones básicas que tiene aduino como las de la clase Serial.

Saludos chato_sat
8  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 17, 2011, 03:47:12 pm
Hola, no te desesperes ni creas que lo que he hecho es increible porque no lo es. Con un poco de práctica tu también lo conseguirás, ninguno nacemos sabiendo  smiley-lol. Para aprender los conceptos básicos de la programación en arduino te sugiero que le eches un vistazo al siguiente post de chiva http://arduino.cc/forum/index.php?topic=50210.0 en él hace una recopilación de fantásticos manuales que te ayudan a iniciarte en la programación de arduino. En este post en la sección de pdf hay 2 manuales en español que están muy bien y además uno de ejercicios resueltos. Verás como no nada difícil hacer esto tú.

Como me has pedido un ejemplo de uso de variables y botones en el código que me has puesto aquí tienes

Code:
#include <Servo.h>

#define BUTTON 2 //declaramos el pin donde va conectado el boton
int myVariable; //declaramos una variable

Servo myservo;   
 
int potpin = 0; 
int val;
///////////////////////////////////////////////////
void setup()
{
  int myVariable = 0; //Inicializamos la variable
  pinMode(BUTTON, INPUT); //Ponemos el pin del botón como entrada
  digitalWrite(BUTTON, HIGH); //Activamos la resistencia pull-up interna del pin
  Serial.begin(9600); //Activamos la comunicación Serie
  Serial.println("Comenzamos el programa"); //Imprimimos algo en la consola
  myservo.attach(9);   
}
////////////////////////////////////////////////////
void loop()
{
  if (digitalRead(BUTTON) == LOW) { //Leemos si hemos pulsado el botón
    Serial.println("Has pulsado el botón"); // Imprimimos en la consola
    Serial.print("myVariable vale: "); //Imprimimos en la consola
    Serial.println(myVariable); //Imprimimos el contenido de myVariable en la consola
    myVariable = myVariable + 10; //Incrementamos myVariable en 10
  }   
  val = analogRead(potpin);           
  val = map(val, 0, 1023, 0, 179);   
  myservo.write(val);                 
  delay(15);                         
}

Como ves en este ejemplo no es difícil hacer que arduino te muestre por la consola si has pulsado un botón y enseñarte el valor de una variable. Pero como te he dicho échale un vistazo a los manuales del enlace que te he dejado y ponle atención al tema de las variables y estructuras de control (if, else, while, for, switch, ...). Si te los lees verás que por ejemplo podrías utilizar arrays para almacenar los botones y sus valores y así ahorrarte unas cuantas líneas de código ya que si utilizas 10 botones repetirás muchísimo código, pero bueno esto ya lo verás poco a poco.

Saludos chato_sat.
9  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 17, 2011, 07:04:32 am
Hola myriam, tal como te dije, aquí te dejo un código que espero que te ayude y te resuelva muchas dudas acerca de como programar. A mí me gusta mucho crear funciones que hagan trabajos básicos y bien definidos para que luego al juntarlas en el loop se quede el código bastante legible.

Me alegro de lo que has dicho en  el post anterior de que quieres aprender a crear y modificar tú el código y no quiero que pienses que al darte este código yo quiero lo contrario, ya que el código te lo doy para que veas un ejemplo de programación sobre lo que tú quieres hacer y así te ayude a comprender la programación en arduino (el código lo he creado después de tu último post con esta finalidad). El código que te doy no está comprobado, con lo cuál puede haber algún error o detalle que se me haya pasado por alto.

Code:
/*
 * Autor: chato_sat
 */

#include <Servo.h>

/* Con el boton de configuración indicamos que queremos entrar o
 * salir del modo configuracion. Está en el pin 2 */
#define BUTTONCONF 2
#define BUTTON1    4
#define BUTTON2    5
#define POTPIN     A0
#define SERVOPIN   9

int pot = 0;     
int posicionActual;
int posicionFinal;

Servo myservo;


// two memories to hold servo positions
int mem1 = 0;
int mem2 = 0;

// ultimo boton leido
int botonLeido = 0;

/* Función que lee los botones y nos devuelve el número
 * del botón que hemos pulsado p.e. 1 Si pulsamos el
 * BUTTON2, 2 si pulsamos el BUTTON2, ... devuelve 0
 * si no hemos pulsado ningún botón */
int leerBotones() {
  if (digitalRead(BUTTON1) == LOW) {
    Serial.println("BUTTON1 PULSADO");
    return 1;
  } else if (digitalRead(BUTTON2) == LOW) {
    Serial.println("BUTTON2 PULSADO");
    return 2;
  }
  /* Si llegamos hasta aquí significa que no hemos
   * pulsado ningún botón y devolvemos 0 */
   return 0;
}

/* Función para indicar si se ha pulsado el botón de configuración.
 * devuelve true si se ha pulsado y false si no se ha pulsado */
boolean pulsadoConf() {
  if (digitalRead(BUTTONCONF) == LOW) {
    Serial.println("BUTTONCONF PULSADO");
    return true;
  }
  return false;
}

/* Función para configurar los botones. Para ello debemos
 * de mover el servo a la posición deseada y pulsar el
 * botón que queremos que tenga ese valor */
 
int configurarBotones() {
  Serial.println("ENTRAMOS EN MODO CONFIGURACION");
  int botonPulsado = 0;
  boolean terminar = false;
  int posicionServo = 0;
  //Podemos configurar todos los botones que queramos ya que
  //hasta que no se vuelva a pulsar el botón de configuración
  //no salimos de él.
  while (!terminar) {
    posicionServo = analogRead(POTPIN); //Leemos la resistencia
    posicionServo = map(posicionServo, 0, 1023, 0, 179); //Convertimos el valor de la resistencia al rango 0-180
    myservo.write(posicionServo);
    botonPulsado = leerBotones();
    if (botonPulsado != 0) { //Comprobamos si se ha pulsado algún botón
      switch (botonPulsado) {
        case 1: //Si hemos pulsado el botón 1 guardamos en la memoria del botón 1
          mem1 = posicionServo;
          Serial.print("BUTTON1 PASA A VALER: ");
          Serial.println(posicionServo);
          break;
        case 2: //Si hemos pulsado el botón 2 guardamos en la memoria del botón 2
          mem2 = posicionServo;
          Serial.print("BUTTON2 PASA A VALER: ");
          Serial.println(posicionServo);
          break;
        default:; //Nunca llegamos a ejecutar default
      }
    }
    terminar = pulsadoConf(); //Comprobamos si se ha pulsado el botón de configuración
                              //para saber si hay que salirnos del bucle
    delay(100);
  }
  Serial.println("SALIMOS DEL MODO CONFIGURACION");
}

/* Función para mover el servo desde la posición en la que estamos
 * hasta la posición que queremos de forma gradual.
 * posicionActual - posicion en la que está el servo
 * posicionFinal - posicion en la que queremos el servo
 * retraso - cuanto queremos que tarde entre las posiciones intermedias
 * p.e. Si queremos mover 100 grados el servo y le ponemos un retraso de
 * 10 entonces tardará 100*10=1000 (el tiempo está expresado en milisegundos)
 */
void moverA(int posicionActual, int posicionFinal, int retraso) {
  Serial.print("MOVIENDO SERVO DESDE LA POSICION ");
  Serial.print(posicionActual);
  Serial.print(" HASTA LA POSCION ");
  Serial.println(posicionFinal);
  if (posicionFinal > posicionActual) {
    for (int i=posicionActual; i<=posicionFinal; i++) {
      myservo.write(i);
      delay(retraso);
    }
  } else {
    for (int i=posicionActual; i>=posicionFinal; i--) {
      myservo.write(i);
      delay(retraso);
    }
  }
  Serial.println("SERVO MOVIDO");
}

void setup()
{
  Serial.begin(9600);
  Serial.println("Start ..");
 
  pinMode(BUTTON1, INPUT);
  pinMode(BUTTON2, INPUT);
  pinMode(BUTTONCONF, INPUT);
  digitalWrite(BUTTON1, HIGH);  // internal pullup
  digitalWrite(BUTTON2, HIGH);  // internal pullup
  digitalWrite(BUTTONCONF, HIGH); //internal pullup
 
  myservo.attach(9);
  posicionActual = 90;
  myservo.write(posicionActual);  // set servo to mid-point
}

void loop()
{
  /* Si leemos el botón de configuración entramos a la configuración*/
  if (pulsadoConf()) {
    configurarBotones();
  } else {
    /* Si leemos alguno de los botones que mueven el servo entonces
     * lo movemos */
    botonLeido = leerBotones();
    if (botonLeido != 0) {
      switch (botonLeido) {
        case 1:
          posicionFinal = mem1;
          break;
        case 2:
          posicionFinal = mem2;
          break;
        default:;
      }
      moverA(posicionActual, posicionFinal, 10);
      posicionActual = posicionFinal;
    }
  }
}

También te dejo para que hagas la función que modifica la velocidad de movimiento del servo, por ejemplo puedes hacer lo siguiente:
- Pones 2 botones uno para incrementar y otro para decrementar la velocidad.
- Haces una función que si pulsas alguno de los botones incremente o decremente el valor de una variable.
- Le pasas la variable al tercer argumento de moverA y listo.

Espero que te resulte de ayuda y para cualquier cosa no dudes en preguntarla.

También me gustaría que me mantuvieras informado de tus avances en el proyecto (esto empieza a interesarme).

Saludos chato_sat.
10  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 17, 2011, 02:46:03 am
Hola myriam, puedes colocar el código que llevas hasta ahora?? así podré hacer las modificaciones sobre tu código y ayudarte.

Lo de escribir en mayúsculas te sugiero que no lo hagas en futuros post, ya que las mayúsculas no dan mucho gusto en los foros porque dan la sensación de que estás gritando.

Saludos chato_sat
11  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 16, 2011, 09:31:02 am
Con cambiar velocidad a que te refieres??

Si te refieres a la velocidad con que se mueve de un punto a otro para que no cambie tan brúscamente puedes probar a hacer una función del tipo:

void moverA(int posicionActual, int posicionFinal) {
  if (posicionFinal > posicionActual) {
    for (int i=posicionActual; i<posicionFinal; i++) {
      myservo.write(i);
      delay(100);
    }
  } else {
    for (int i=posicionActual; i>posicionFinal; i--) {
      myservo.write(i);
      delay(100);
    }
  }
}

i++ e i-- sería el paso de grados que quieres, aquí está establecido de 1 en 1 grado. También puedes hacer con delay que se espere más o menos tiempo.

Para que se quede en la posición anterior hasta la siguiente orden puedes hacer lo que dijo el compañero aero_yo: Poner otro interruptor que indique en que modo estás, es decir, si lo pulsas entras en modo grabación y si no envías los valores de los botones.

Espero que te sirva.

Saludos chato_sat
12  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 16, 2011, 06:48:51 am
Sí, claro que los puedes usar. Lo que pasa es que tendrás que ingeniartelas para conectar esos conectores de la placa a tu arduino (supongo que soldando cables o pines sobre ellas con cuidado se podrá hacer). Por lo que se aprecia en la ultima foto que has subido la patilla de la derecha parece ser el común y cada una de las otras salidas corresponde a uno de los switch. Para comprobar que switch es cada patilla puedes seguir su pista o utilizar un multímetro para medir continuidad.

En el caso del programa que has puesto el común debería de ir conectado al gnd del arduino para que al pulsarlos te de el valor LOW.

Ánimo y saludos chato_sat.
13  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 16, 2011, 02:47:18 am
Hola myriam.

Este código puede ser un buen comienzo ya que utiliza botones, potenciómetro y servo que es lo que tú quieres. Intenta entender línea a línea que es lo que hace y hazle modificaciones poco a poco hasta conseguir lo que quieres.

Un consejo utiliza Serial.print para ver por la consola del arduino que es lo que está haciendo el programa en todo momento. En este código no las utiliza, pero te aconsejo que declares funciones que tengan una finalidad concreta, ya que así el código se te quedará más legible (como puede ser configurar los botones, leer la configuración inicial, mover servo, ...).

Saludos chato_sat.
14  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 15, 2011, 04:45:02 pm
Cualquier duda que tengas estaré encantado de ayudarte.

En principio veo que el código es correcto, sólo me mosquea un poco esta parte:

// READ POT
  pot = analogRead(POTPIN)/4;  // 0..1023
  servoValue = pot/4;

En ella hace que el servoValue tenga valores desde 0 hasta 63 y la librería servo.h admite los valores de 0 a 180 (que son supuestamente los grados máximos del servo) con lo cual está limitando el servo a 63 grados.

La primera vez que pulsas un botón se guarda el valor en una variable para que las sucesivas pulsaciones de ese botón el servo vaya hacia esa posición. Lo que pasa es que si sueltas el botón el servo volverá a la posición que le marque la resistencia. No se si esto es lo que quieres o que cuando pulses el botón y mientras no pulses otro botón el servo se mantenga en la posición del último botón pulsado (no se si me he explicado).

Los botones una vez pulsados la primera vez, no puedes volver a cambiarles el valor, a no ser que reinicies el arduino.

También al no usar la EEPROM todo lo que guarda es volátil, es decir que cada vez que inicies el arduino deberás configurar los 2 botones de nuevo.

Todo esto que he dicho ha sido desde la teoría ya que yo no he probado el código. Para cualquier modificación no dudes en postearlo y estaré encantado de ayudarte.

Saludos chato_sat.
15  International / Español / Re: cualquier respuesta puede ser de ayuda on: May 15, 2011, 02:56:44 pm
Quote
// la direccion actual en la EEPROM                    A QUE SE REFIERE CON  ( la direccion actual en la EEPROM )
// (p.e. cual es el siguiente byte a escribir)          QUE SIGNIFICA     ( p.e )

La EEPROM es una memoria que no es volátil y como tal se pueden almacenar datos de manera permanente (que no se borren cuando apagamos el arduino). El arduino uno contiene 1KB  de memoria EEPROM, lo que quiere decir que podemos escribir hasta 1024 bytes en ella.

Con la dirección se refiere en cuál de los bytes que contiene la EEPROM queremos escribir. Por ejemplo si queremos escribir en el primer byte de la EEPROM pondremos direccion=0.

p.e. es la abreviación de "por ejemplo"

Quote
// Estos valores quedarán en la EEPROM cuando la placa se apague.                 ok me parese claro pero como puedo designar botones, para que cuando lo presioné  comience a leer el valor

Esta pregunta se puede resolver de muchas formas, yo te aconsejo que al principio del programa (Si ya tienes los valores guardados en la EEPROM) leas ese valor y lo asignes a una variable y cuando pulses un botón escribas la variable en el servo.

Quote
// incrementa "direccion" en 1 para avanzar a la siguiente dirección de la EEPROM        si me responden la primer pregunta creo que también se aclara esta cual es la siguiente dirección
  direccion = direccion + 1;

Aquí lo que se hace es decir que se quiere escribir el siguiente byte de la EEPROM

Quote
/ Solamente hay 512 bytes de EEPROM, desde 0 hasta 511                                      lo que entiendo aquí es que se ejecuta en automático cada función por orden
  // Si estamos en la direccion 512, volvemos a la dirección 0                                       como designo las  funciones en botones

Efectivamente este programa lo que hace es guardar los valores que leemos desde el pin analógico 0 en la EEPROM de forma secuencial desde el 0 hasta el 512 y cuando llega a este volvemos a empezar.

Intentaré crear un pequeño programilla y lo comentaré lo máximo posible para intentar ayudarte lo máximo posible, pero te aconsejo que le eches un vistazo a los tutoriales e intentes comprender línea a línea todo el código de cada uno de los ejemplos.

Saludos chato_sat.
Pages: [1] 2 3 4