Página traducida.

Capítulo 9: Escribiendo Programas

Un programa en Arduino está hecho de código, escrito en un lenguaje de programación llamado C. Cuando escribimos un código es importante tener en cuenta que Arduino no actúa como un ser humano, no razona. Si alguien pronuncia una palabra incorrecta probablemente entendamos el significado – Arduino sin embargo no. Si tecleas incorrectamente un comando mientras escribes código en el IDE de Arduino, no va a entender lo que quieres hacer.

Otra cosa a tener en cuenta es que Arduino es lógico pero no racional. No sabe que quieres hacer, sólo hace lo que le digas hacer.

Estructura Básica

Cuando escribimos código en el IDE de Arduino usamos tres partes básicas en la estructura del programa.

  • declaración de variables
  • setup()
  • loop()

Las funciones setup() y loop() son esenciales escribirlas para el funcionamiento del programa. A medida que tengas más confianza en la escritura de código para Arduino te darás cuenta que no es obligatorio para escribir código usar estos pasos. Sin embargo viene bien estructurar el programa para hacer fácil su revisión y ayuda a buscar errores en el código. El siguiente código es un ejemplo de un programa sencillo que hace parpadear el LED de la placa Arduino:

int ledPin = 13;
void setup(){
        digitalWrite(ledPin,OUTPUT);
}
void loop(){
        digitalWrite(ledPin,HIGH);
        delay(1000);
        digitalWrite(ledPin,LOW);
        delay(1000);}

Variables

Una variable es un contenedor para guardar algún dato. Digamos que quiere leer un sensor de algún tipo. Este sensor te dará un valor en formato numérico. Si quiere usar este valor en otra parte del programa puede guadar este valor en una variable. Antes de almacenar el valor necesita declarar la variable, esto significa que le digas al programa que la variable existe y que tipo de variable es.

Tenemos que poner un nombre a la variable. El nombre podría ser cualquiera pero es una idea buena dar a sus variables nombres que sean lógicos. Cuando revisé su programa será fácil determinar qué tipo de valor se almacena en una variable nombrada “temSensor”. Puede ser más difícil recordar cual es el contenido en variables con nombres como “banana”, “peter” o “supercalifragilisticexpialidocious”. Más explicaciones en la sección Tipos y Declaraciones de Variables en las páginas 80-82.

  1. Referencia cruzada dentro del libro. "Más explicaciones en la sección Tipos y Declaraciones de Variables en las páginas 80-82." (puede no cuadrar con la maquetación en español). ################################

Void setup

Arduino lo primero que hace cuando arranca es mirar la void setup(). Éste es uno de los pasos esenciales del funcionamiento del programa. La void setup() es la parte que inicializa las configuraciones de los diferentes elementos del programa de Arduino; por ejemplo la configuración de un pin o establecer la velocidad de comunicación. La void setup() sólo se ejecuta una vez en el inicio y no se volverá a ejecutar hasta que Arduino se apagué y vuelva a arrancar o se resetea.

El siguiente código es un ejemplo de una void setup que pone la configuración de un pin como salida.

void setup(){
        pinMode(pin,OUTPUT);}

Void loop

La void loop() es el segundo paso esencial para el funcionamiento de un programa. Aquí es donde se ejecutan las acciones de su programa. Como su nombre indica, ésta parte se ejecuta una y otra vez. En un programa de Arduino todo el código se ejecuta línea a línea. Después de ejecutar la void setup() en el arranque continua con la void loop().

Entonces empieza a hacer todo lo que está en su código desde el comienzo hasta el final de la void loop(). Cuando llega al final de la void loop() simplemente vuelve a empezar con los cambios del programa. El siguiente código es la void loop() del ejemplo del principio del capítulo:

void loop(){
        digitalWrite(ledPin,HIGH);

     delay(1000);

     digitalWrite(ledPin,LOW);

     delay(1000);
}

Esta void loop() empieza con una línea de código que activa el pin cuyo número se indica en el nombre de la variable “ledPin”. La siguiente línea de código produce un retardo y después desactiva el mismo pin y a continuación realiza un nuevo retardo. Si ejecutamos este código en Arduino con un LED conectado al pin con el número indicado en la variable “ledPin”, el LED parpadeará encendiéndose y apagándose con un segundo de retardo hasta apagar la alimentación.

Marcas de puntuación. Paréntesis y llaves

Las marcas de puntuación se utilizan para definir el inicio y el final de ciertas partes del código. Hay dos tipos de marcas usados en la escritura de código para Arduino. Los primeros son los paréntesis izquierdo y derecho () y son normalmente llamados entre paréntesis. Estos soportes se utilizan para escribir funciones dentro de nuestros programas. Se utilizan para intercambio de una variable en algún otro lugar dentro de nuestro programa.

También es posible tener una función con los paréntesis vacíos, pero es necesario poner después el nombre de la función o Arduino tendrá un error de compilación. Un ejemplo de funciones que utilizan paréntesis vacíos son la void setup() y la void loop().

El segundo tipo son las llaves {}. Estas se usan para indicar el principio y final de una función. Sin estas llaves Arduino no será capaz de saber dónde empieza y termina la función y que se considera como la siguiente parte del código. Un uso común de estas llaves se hace en la función void setup().

void setup(){

     //The code in the function goes in here.

}



Punto y coma

Los puntos y comas son uno de los elementos más importantes para escribir código para Arduino y uno de los que más fácilmente nos olvidamos. Se usan para separar las diferentes líneas de código en su programa e indica a Arduino donde termina su comando. El siguiente ejemplo se muestra como se declara una variable con el uso correcto del punto y coma.

int myNumber = 15;

El punto y coma termina el comando y hemos declarado una variable entera con el nombre “myNumber” y esta variable tendrá el valor 15. Si te olvidas un punto y coma en tu código el IDE de Arduino resaltará la línea de código indicando la falta de punto y coma.

Comentarios de código

A veces puede ser útil para poner notas o escribir comentarios dentro de su código para uno mismo o para otra persona. Si se escribe el texto dentro de su programa Arduino piensa que es de código e intenta ejecutar lo que está escrito. Si lo que está escrito es algo que el Arduino no entiende, le dará un mensaje de error.

Hay dos maneras de escribir mensajes en el código y ocultarlo a Arduino. La primera de ellas es el uso de una doble barra / / delante de cualquier mensaje. Esto oculta el mensaje a Arduino pero deja lo visible para los programadores. El siguiente es un ejemplo de un mensaje oculto dentro de loop():

void loop(){
        digitalWrite(ledPin,HIGH); // turns the led on
        delay(1000); // wait for some time
        digitalWrite(ledPin,LOW); // turns the led off 
        delay(1000); // wait a bit more

}

 Si desea ocultar los mensajes de más de una línea tiene que utilizar / * y * /. Para marcar el inicio de un mensaje que se oculta, se usa / * y para marcar el final del mensaje, use el / *. Esto ocultará todo el mensaje. El siguiente código es un ejemplo de cómo ocultar un bloque de texto dentro de loop():

void loop(){
        /* this code will first turn a led on then it will wait 
     for some time after that it will turn the led off and   
     then wait again. */
        digitalWrite(ledPin,HIGH);
        delay(1000);
        digitalWrite(ledPin,LOW);
        delay(1000);
}



Tipos de variables y declaraciones

Dar a una variable un valor es también conocido como declarar una variable. Declarar una variable es definir un tipo, nombre y valor para la misma.

int myNumber = 14;

En el ejemplo anterior el "int" es el tipo de variable, "miNumero" es el nombre y 14 es el valor. Ten en cuenta que siempre tienes que darle un valor a la variable cuando la declaras. Suponemos que quieres guardar un valor de tu sensor en tu programa, pero no puedes leer el valor cuando declaras la variable fuera del void loop(), en el inicio del programa. Tú le das un valor temporal 0 a la variable cuando la declaras al inicio, como en el siguiente ejemplo:

int mySensor = 0;

Hay dos posibles maneras de declarar una variable. Si la declaras al principio de tu programa, antes del void setup() diremos que es una variable global. Una variable global es accesible desde cualquier parte de tu programa. Por otro lado tenemos las variables locales, que sólo pueden usarse dentro de la función en la que se declararon. El siguiente ejemplo muestra una variable global llamada ledPin:

int ledPin = 13;


void setup(){
        digitalWrite(ledPin,OUTPUT);}

void loop(){
        digitalWrite(ledPin,HIGH);
        delay(1000);
        digitalWrite(ledPin,LOW);
        delay(1000);
}

 La variable ledPin es visible en todo el programa y cuando es usada dentro de void loop(); será reconocida como una variable de tipo entero (integer) con el valor 13. Sin embargo, si escribes el mismo programa de la siguiente manera:

void setup(){

     int ledPin = 13;

     digitalWrite(ledPin,OUTPUT);
}


void loop(){

     digitalWrite(ledPin,HIGH);

     delay(1000);

     digitalWrite(ledPin,LOW);

     delay(1000);
}

Entonces el programa te dará un error diciendote que no puede encontrar la variable ledPin que intentas usar dentro de void loop();, ya que está declarada dentro (y sólo dentro) de la función void setup();

En algunos programas puede ser útil usar variables locales, pero en la mayoría de los casos es mejor declararlas como variables globales y, por tanto, declararlas antes del void setup();

Una vez que tienes una variable con un valor, tu puedes asignarle otro valor, pero ten en cuenta que borrarás el que existía previamente.Supongamos que tenemos una variable llamada miNumero y la hemos declarado como:

int myNumber = 14;

Si a lo largo de tu programa quieres darle otro valor a "myNumero", lo harás así:

myNumber = 56;

Esto borrará el número 14 de la variable "myNumero" y lo reemplazará por el número 56. Cuando reasignamos valores las variables, no tenemos que añadir "int" al comienzo de la linea de código como hicimos cuando la declaramos. Ésto es porque nosotros sólo declaramos el tipo de variable una vez en el programa. Es posible cambiar el valor de la variable, pero no su tipo.

Tipos

Hasta ahora hemos estado hablando de "int", que es el la abreviatura de número entero (el tipo más común de variables en programas de Arduino). Las variables comunes son:

  • Int: Los enteros se usan para guardar datos numéricos sin puntos decimales. Almacenan un valor de 16 bits en el rango de 32767 a -32767. Esto quiere decir que un entero (int) ocupa 16 bits en la memoria de Arduino y puede ser cualquier número entero entre -32767 y 32767.

int myNumber = 1234;

  • Long: En muchos casos el tamaño de un entero nos valdrá pero, en otros, necesitaremos almacenar variables más grandes que el tamaño que nos permite el tipo "int", para ello usaremos el tipo "long". El tipo "long" extiende el rango de valores enteros (sin decimales) a un valor de 32 bits, esto es un rango de 2147483647 a – 2147483647. Igualmente esto quiere decir que un número "long" ocupará 32 bits en la memoria de Arduino y nos permitirá usar valores entre – 2147483647 y 2147483647.

long myBigNumber = 90000;

  • Byte: Para ahorrar espacio en la memoria de Arduino, es útil almacenar las variables como bytes. Un byte es un número entero de 8 bits con un rango de 0 a 255. Con un byte ocuparemos 8 bits de la memoria de Arduino y podremos representar cualquier número entero entre 0 y 255.

byte mySmallNumber = 150;

  • Float: El único tipo de datos que puede guardar números con decimales es "float". Float tiene mayor resolución que los enteros (int, long, byte) y se guardan como un valor de 32 bits en el rango desde 3.4028235E+38 a – 3.4028235E+38. Esto quiere decir que puedes guardar un número decimal pero sólo en ese rango. Los números decimales (float) ocupan mucha memoria de Arduino. Usar decimales es mucho más lento que usar enteros, pues Arduino necesita más tiempo para realizar cálculos con éstos.

float mydecimalNumber = 2.33;

  • Arrays (Matrices): A veces puede ser útil guardar una colección de valores, entonces tendremos que utilizar una matriz. Todos los valores almacenados en una matriz se guardarán con un número índice, para acceder a cualquier valor lo harás referenciando su número índice. Las matrices se declaran de igual modo que las variables (con el tipo, el nombre y los valores). El siguiente ejemplo muestra como declarar una matriz de enteros con seis valores distintos:

int myArray[] = {1, 2, 3, 4, 5, 6};

Ten en cuenta que las matrices empiezan a contar desde 0. Esto significa que la primera posición de la matriz es 0. En el ejemplo anterior, el número 1 está guardado en la primera posición de la matriz, por tanto, si queremos utilizarlo lo haremos del siguiente modo:

myNumber= myArray[0];

Esto almacenará el valor de la primera posición de la matriz (el valor 1), en nuestra variable miNumero. Por otro lado, podemos almacenar valores en la matriz haciendo referencia a la posición del número que nos interesa:

myArray[0] = 23;

Esto guardará el número 23 en la posición 0 de la matriz (donde antes estaba el valor 1).

Si sabes que vas a usar una cantidad de números y los quieres almacenar en una matriz, pero no sabes qué valores van a ser, puedes declarar la variable reservando el número de posiciones que quieras, del siguiente modo:

int myArray[5];

Esto creará una matriz de 5 posiciones, donde 4 será la última (Recordemos que empieza a contar de 0). No intentes almacenar datos en la quinta posición, esta posición será incorrecta, pero Arduino no te avisará a la hora de comprobar el código.

Haciendo cálculos

Como Arduino es un pequeño ordenador, puede hacer operaciones matemáticas. Puede realizar las operaciones matemáticas más habituales como son, la suma, la resta, la multiplicación y la división.

myValue = 1 + 1;
        /* esto guardara el número 2 en myValue */
myValue = 4 - 2;
        /* esto guardara el número 2 en myValue */
myValue = 3 * 4;
        /* esto guardara el número 12 en myValue */
myValue = 6 / 2;
        /* esto guardara el número 3 en myValue */

Si estás usando enteros para realizar las operaciones matemáticas no podrás obtener decimales, "float" es el único tipo de variable que puede obtenerlos. En otras palabras, si quieres dividir 10 entre 6, dará 1 como resultado. Hacer cálculos demasiado largos puede producir un desbordamiento en la memoria de Arduino, ya que todo tipo de variable tiene un tamaño máximo. Realizar cálculos con números grandes ralentizará el Arduino.

Puedes realizar cálculos entre variables, a continuación tienes los diferentes cálculos que se pueden aplicar a las variables:

x++     /* incrementara en 1 el valor de x. Es lo mismo que
        escribir x = x + 1 */

x--     /* decrementara en 1 el valor de x. Es lo mismo que
        escribir x = x - 1 */

x +=/* incrementara el valor de y al valor de x. Es    
        lo mismo que escribir x = x + y*/

x -=/* decrementara el valor de y al valor de x. Es lo
        mismo que escribir x = x - y */

x *=/* multiplicara x por y. Es lo mismo que escribir x = x * y*/
x /=/* dividira x entre y. Es lo mismo que escribir x = x / y  */

  • Mapeo

Supongamos que tienes un sensor que solo proporciona valores entre 50 y 200, y que tú necesitas un rango desde 0 a 500. La función "map" puede ser útil. Ésta función remapea un rango de valores a otro rango de valores. Digamos, hace una regla de 3:

myVariable = map(mySensor,50,200,0,500);
        /* valorSensor, valorMinSensor, valorMaxSensor,
        minimoDeseado, maximoDeseado */

En el ejemplo anterior estamos usando la función "map" para guardar un valor en miVariable. El valor proviene de miValor y el 50 y el 200 marcan los valores mínimo y máximo de nuestro sensor. El 0 y el 500 es el rango deseado. La función "map" asignará el valor obtenido (dentro del rango del sensor, 50-200) al rango deseado (0-500). Observe que si quieres usar la función "map" debes conocer el rango que quieres "mapear". Para encontrar más información sobre cómo leer valores vaya a las páginas 98-101.

  1. Referencia cruzada dentro del libro. "vaya a las páginas 98-101", puede no cuadrar con la maquetación en español. ################################

  • Random(max) (Aleatorio(máximo))

El comando "random" devolverá un valor aleatorio en el rango comprendido entre 0 y el valor que pongas entre paréntesis. Para poder usar ese valor tienes que guardarlo en una variable.

myVariable = random(5);

Ésto guardará un número aleatorio en miVariable, dentro del rango de 0 a 4. También puedes usar el comando "random" directamente mientras haces comparaciones:

if (3 == random(5)){

        doSomething;

}

El comando "random" sólo devolverá un valor entre 0 y el máximo establecido, nunca devolverá ese máximo.

  • Random(min,max)

Si quieres un número aleatorio comprendido en un rango que comience en un valor distinto de 0, debes especificar dicho mínimo:

myVariable = random(200,300)

Comparaciones lógicas

Si quieres realizar comparaciones en tus programas debes usar alguno de estos comparadores. Estas comparaciones se pueden realizar entre variables o con constantes, obteniendo siempre valores Verdadero o Falso.

  • Igual a ==

== es usado para comparar si un elemento es igual a otro. Una comparación usando == sólo será verdadero si ambos miembros de la igualdad son idénticos:

x == y
        /* x es igual a y */

  • Distinto de !=

'!= se usa para comprobar si un elemento es distinto de otro. Una comparación usando != sólo será Verdadero si un miembro es distinto del otro:

x != y
        /* x es distinto de y */

  • Menor que <

< se usa para comparar si un elemento es menor que otro. Una comparación usando < sólo será Verdadero si el miembro izquierdo es menor que el derecho:

x < y
        /* x es menor que y */

  • Mayor que >

> se usa para comparar si un elemento es mayor que otro. Una comparación usando > sólo será verdadero si el miembro izquierdo es mayor que el derecho:

x > y
        /* x es mayor que y */

  • Menor o igual <=

<= se usa para comparar si un elemento es menor o igual que otro. Una comparación usando <= sólo será verdadera si el miembro izquierdo es igual o menor que el derecho:

x <= y
        /* x menor o igual que y */

  • Mayor o igual >=

>= se usa para comparar si un elemento es mayor o igual que otro. Una comparación usando >= sólo será verdadera si el elemento izquierdo es mayor o igual que el derecho:

x >= y
        /*x es mayor o igual que y*/

Operadores Lógicos

Los operadores lógicos se usan cuando necesitas dos o más elementos en la misma sentencia, y éstos pueden ser verdaderos o falsos. Se pueden utilizar tros comparadores lógicos.

  • Y (&&)

Se usa para determinar si dos o más elementos son verdaderos. SI alguno de los elementos no es verdadero, la sentencia será falsa. Para que algo sea verdadero, todos los elementos deben serlo, para que sea falso, con que uno sea falso, la sentencia lo será:

x < y && y > 5
        /* x es menor que y, e y es mayor que 5 */

  • O (||)

Se usa para determinar si alguno de los dos elementos es verdadero. Con que alguno de los elementos sea verdadero, la sentencia será verdadera:

x < y || y > 5

	/* x es menor que y, o y es mayor que 5. Nota: Los dos elementos pueden ser 
		verdaderos */

(:sourcend:)

  • Negacion (!)

Se usa para determinar si algo no es verdad. Si no se cumple, la sentencia será verdadera:

x!=5
        /* x no es igual a 5 */

Constantes

Las constantes son palabras que Arduino utiliza y que tienen valores predefinidos. Se usan para simplificar la lectura del codigo de tu programa.

  • True and False (verdadero y falso)

True y False son lo que llamamos constantes Booleanas y definen si algo lo es, o no, a nivel lógico:

boolean myBoolean = true;

Cualquier número puede usarse como operador Booleano. Por ejemplo, 200 se puede usar como operador, y si una variable tiene ése valor y lo comparamos con 200, ésto nos devolverá Verdadero:

int myNbrBoolean = 200; /* Asignamos el valor a la variable*/
myNbrBoolean == 200; /* Comparamos myNbrBoolean con 200, devolvera Verdadero */

También se puede escribir con un número

int myNbrBoolean = 1;

En el primer ejemplo necesitamos comparar miBooleano con otro Booleano, y en el segundo caso comparamos miOtroBooleano con otro entero.

  • High y Low (Alto y Bajo)

HIGH y LOW se usan para determinar el estado de un pin digital, que sólo tiene esos dos estados. HIGH quiere decir lo mismo que ON (o que hay 5 voltios en tu pin digital). Es lo mismo que un 1 lógico. LOW quiere decir lo mismo que OFF (o que hay 0 voltios en tu pin). Es lo mismo que un 0 lógico:

digitalWrite(ledPin,HIGH);

Esto se puede escribir también con números:

digitalWrite(ledPin,1);

  • Input y Output (Entrada y Salida)

INPUT y OUTPUT se usan cuando declaramos el modo de funcionamiento de nuestro pin digital, sólo existen esos dos modos:

pinMode(12,OUTPUT);

Si ocurre algo y qué hacer

Supongamos que estás trabajando en un prototipo y estás midiendo una distancia. Cuando algo se acerque a una distancia del objeto, quieres que ocurra algo. Aquí es cuando la sentencia If es útil.

  • If (Si)

Una sentencia If es como un test que Arduino puede hacer para determinar si algo es verdadero o falso. Una sentencia If sigue esta estructura:

if (myVariable>myOtherVariable){
        doSomething;
}

En este ejemplo preguntamos si miVariable es mayor que miOtraVariable. SI es así, el programa saltará dentro de la función If y ejecutará el código (hazAlgo). Si la comparación resulta ser falsa, el programa saltará esta parte de código. En este ejemplo hemos comparado variables, pero también podríamos comparar constantes:

if (buttonPin==HIGH){
        doSomething;
}

En este ejemplo preguntamos si botonPin está HIGH, en cuyo caso leeremos el código hacerAlgo, de lo contrario omitirá el código de la función.

No olvides usar == cuando realices comparaciones. Si usas sólo un = no compararás un elemento con otro, sino que asignarás el valor del segundo elemento al primero.

if (buttonPin=HIGH){
        doSomething;
}

El ejemplo anterior muestra la manera incorrecta de escribir una sentencia If. En este ejemplo estamos definiendo botonPin como HIGH en lugar de comprobar si botonPin está en HIGH. El compilador de Arduino no te avisará de este error.

  • If else (Si .. si no .. )

Ahora supongamos que quieres hacer una comprobación, y que sabes qué hacer tanto si se da la condición, como si no. Lo que puedes hacer es conectar una sentencia Else (si no ...) a tu sentencia If:

if (myVariable>myOtherVariabel){
        doSomething;
        } else {
        doAnotherThing;
}

El ejemplo anterior trabaja del siguiente modo: Si miVariable es mayor que miOtraVariable, entonces realiza hazAlgo. Si miVariable no es mayor que miOtraVariable, entonces realiza hazOtraCosa.

No olvides usar otro par de llaves ( {} ) para delimitar el comienzo y final de la sentencia Else.

Puedes añadir tantas condiciones Else como quieras dentro de una sentencia If, pero si quieres añadir más de una, tienes que escribir todas ellas, menos la última, con un Else if seguido de una nueva condición:

if (myVariable>myOtherVariable){
        doSomething;
        } else if (myVariable<100){
        doAnotherThing;
        } else {
        doTheLastThing;
}

En el ejemplo anterior, si miVariable no es mayor que miOtraVariable, entonces pregunta si miVariable es menor que 100 y, si no es cierto, entonces realiza hazUnaUltimaCosa.

  • For (Durante)

Los bucles Fot se usan cuando quieres repetir una parte del código un número concreto de veces. El bucle For siempre tiene tres parametros entre paréntesis, éstos son: la inicialización del contador, la condición para terminar el bucle y el incremento de tu contador.:

for (int i=0; i<200; i++){
        doSomething;
}

En este ejemplo "int i=0;" es la inicialización del contador para el bulce For. Aquí decimos que queremos un contador con el nombre "i" y de tipo "int", y que queremos empezar a contar desde 0. Cuando hayamos terminado de definirlo, terminamos con un punto y coma, y pasamos a la segunda parte. Definimos la condición, si i<200 terminaremos el bucle. La última parte define nuestro incremento por cada pasada en el bucle. i++ incrementará el contador en una unidad por cada pasada. La primera vez, el contador estará a 0, la siguiente estará a 1 y así sucesivamente. Cuando i alcance el valor 200, la condición i<200 ya no se cumplirá, por lo que saldremos del bucle y continuaremos con el código escrito después de la llave de cierre del bucle (}).

  • While (Mientras...)

Un bucle While durará hasta que la condición entre paréntesis sea falsa. Si usas un bucle While, debes asegurarte que la condición debe poder variar de algún modo (incrementandose, mediante comparaciones..) de no ser así el bucle no terminaría nunca:

while (myVariable<100){
        doSomething;
}

Este ejemplo comprueba si miVariable es menor que 100. Si es así, entonces comienza el bucle, pero si dentro de mi bucle no hay nada que haga cambiar el valor de miVariable, el bucle no terminará nunca.

En el siguiente ejemplo hemos añadido la lectura de un sensor:

while (myVariable<100){
        doSomething;
        myVariable = readSensor;
}

Ahora cada vez que se se repita el bucle, primero realizará hazAlgo, y después guardará en miVariable, el valor obtenido en la lectura del sensor. Si el valor almacenado en miVariable es superior a 100, el bucle While se detendrá y continuará leyendo el código escrito despues de la llave de cierre. Asegurate de, si estás usando un sensor para salir del bucle, éste pueda proporcionarte un valor que cumpla tu condición del bucle.

Los pines digitales

These pins are the 0 to 13 pins on your Arduino and they are called digital because they can only handle information as 0 or 1. If you want to use a digital pin, the first thing you have to do is to set the mode of the pin. This is always done in the void setup().

Estos pines son los pines del 0 al 13 de tu Arduino y se llaman digitales porque sólo pueden manejar valores 0 o 1. Si quieres usar un pin digital, lo primero que tienes que hacer es configurar el modo de trabajo del pin. Ésto se hace siempre en el void setup().

The command for setting the mode of a pin is pinMode() and is used as follows:

pinMode(pin,OUTPUT);

El comando para configurar el modo de trabajo es pinMode() y se usa del siguiente modo:

pinMode(pin,OUTPUT);

En este ejemplo "pin" es una variable con el valor correspondiente al número del pin a utilizar. OUTPUT es el modo de trabajo que queremos definir. Un pin digital tiene sólo dos modos, OUTPUT (salida) e INPUT (entrada). Si declaras un pin como OUTPUT, sólo podrás usarlo para activarlo, aplicando 5V en el pin, o para desactivarlo, aplicando 0V en el pin. Si configuras el pin como INPUT, sólo podrás usarlo para leer si hay 5V o 0V en el pin:

digitalWrite(pin,valor);

Para encender o apagar tu pin digital debes usar el comando digitalWrite(). Entre paréntesis debes indicar qué pin modificar, y qué valor darle:

digitalWrite(pin, HIGH);

Ésto pondrá el pin en su estado HIGH, proporcionando 5V en él. Si escribes LOW en lugar de HIGH apagarás el pin, volviendolo a dejar en 0V.Ten en cuenta que hasta que definas el estado del pin como HIGH su valor por defecto será LOW. Si miras tu placa Arduino, verás que los pines digitales 0 y 1 están marcados como RX y TX. Estos pines están reservados para la comunicación serie y no deben ser usados, ya que pondrán a Arduino en modo de espera hasta que se reciba una señal.

  • DigitalRead(pin) (Lectura de pin digital)

El comando digitalRead() lee el estado de un pin y devuelve HIGH si está a 5V o LOW si hay 0V en él:

digitalRead(pin);

Para poder usar el valor del estado para algún fin debes guardarlo en una variable:

myVariable = digitalRead(pin);

Si quieres realizar una comparación puedes escribir el comando directamente en la sentencia:

if (digitalRead(pin)==LOW){

     doSomething;
}

Aunque LOW equivale siempre a 0V en una salida digital, en una entrada digital cualquier valor entre 0V y 1.5V se considerará LOW en el comando digitalRead(). Del mismo modo todos los valores entre 3.3V y 5v se considerarán como un valor HIGH.

Los pines analógicos

Los pines analógicos y digitales funcionan de diferente manera. Hemos mencionado que los pines digitales sólo manejan información en 1 y 0, lo que es lo mismo como ALTO (HIGH) y BAJO (LOW) o 0V y 5V. Sin embargo, en el mundo real no medimos sólo ceros y unos así Arduino tiene seis pines especiales analógicos que hacen un cálculo del voltaje en un rango codificado de 0 a 1023. Los pines analógicos no deben ser declarados, su configuración de I/O, ya que sólo son utilizados como entradas.

  • Analog read (pin)

Para leer el valor de un pin analógico tienes que usar el comando analogRead() y poner la referencia del pin que deseas leer:

analogRead(pin);

Al igual que con el pin digital, tienes que guardar este valor en una variable para poder usarlo

myVariable = analogRead(pin);

Puedes usar el comando directamentepara hacer comparaciones

if (analogRead(pin)>500){

     doSomething;
}

  • Analog write (pin,value)

Los pines digitales sólo puede ser HIGH y LOW, que es lo mismo que tener 5V o 0V en los pines digitales. Sin embargo, para los pines digitales 3, 5, 6, 9, 10 y 11 tenemos una función especial llamada analogWrite (). Con esta función es posible enviar un valor pseudo-analógico a estos pines digitales especiales. Esto se denomina modulación por anchura de pulso (PWM, pulse with modulation):

analogWrite(pin,value);

El valor de este ejemplo puede ser desde 0 a 255. Si escribes un 0, esto sería lo mismo que el poner en el pin LOW, y 255 es lo mismo que HIGH. Pero con analogWrite() obtienes 255 pasos entre HIGH y LOW, así por ejemplo:

analogWrite(pin,127);

Esto sería similar a enviar 2.5V al pin digital. En comparación con el digitalWrite(), que pasa de 0 V a 5 V en un instante, con la analogWrite() puede hacer una transición más lenta de 0V a 5V. Tenga en cuenta que la analogWrite() sólo funciona en los pines digitales marcadas con PWM (3, 5, 6, 9, 10 y 11) y no en los pines de entrada analógica de a0 a a5.

Using time

Usando el tiempo

The Arduino is a small but powerful computer and can carry out 1,000,000 calculations per second. When you are making prototypes you may not want to execute at this lightning speed. Then you’re going to have to tell the Arduino to slow down every now and then.

Arduino es una pequeña computadora, pero poderoso y puede realizar 1.000.000 operaciones por segundo. Cuando vaya a hacer prototipos que no quiera ejecutar a una velocidad tan rápida. Vas a tener que decirle a Arduino que pare de vez en cuando.

  • Delay (retardo)

The delay command is used to set a pause in your program. This command counts in milliseconds and you enter your desired pause time within the parentheses as in the following example:

delay(1000);

This delay will set a pause in your program of one second.

Este delay pondrá una pausa en su programa de un segundo,

  • Count milliseconds

  • Contar milisegundos

This command will return how many milliseconds have passed since the Arduino started the currently running program. To be able to use this value you have to save it in a variable:

Este comando millis() devolverá cuantos milisegundos han pasado desde que Arduino inició la ejecución del programa. Para poder utilizar este valor hay que guardarlo en una variable:

myVariable = millis();

You can use it directly to make time comparisons:

Puede usarlo directamente para hacer comparaciones de tiempo:

if (myAlarmTime == millis()){
        ringAlarm;
}
Comunicación con otros dispositivos

Para ser capaz de comunicarse con otros dispositivos electrónicos debe habilitar los puertos de comunicación de Arduino. Arduino puede comunicarse con el ordenador y con otros dispositivos electrónicos que utilizan el protocolo de comunicación serie.

Los pines digitales 0 y 1 de Arduino se reservan para comunicaciones en serie con otros dispositivos y debería evitar usar estos dos pines para otras tareas, ya que puede interferir con el funcionamiento de su programa.

  • Serial begin

Para permitir la comunicación de Arduino se utiliza el comando Serial.begin(). Este comando se utiliza sólo en el void setup(). Dentro de los paréntesis se introduce la velocidad de comunicación deseada en bits por segundo, lo que también se conoce como baudios, y las velocidades disponibles son 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200:

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

Este código abrirá el puerto serie y pone la velocidad de comunicación a 9600 baudios.

  • Serial println

Este comando va a imprimir lo que pones dentro de los paréntesis y añadir un final de línea. Para imprimir números enteros tiene que poner el tipo dentro de los paréntesis:

Serial.println(12345);

Sin embargo, los caracteres de impresión y cadena de caracteres debe ser citado. Si desea imprimir un solo carácter usa las comillas simples ‘ ‘:

Serial.println(‘C’);

La línea de código anterior enviará el carácter C a través del puerto serie. Si desea imprimir una cadena de caracteres, como mensaje tiene que utilizar las dobles comillas “ “

Serial.println(“Hello from Arduino”);

  • Serial print

El Serial.print() trabaja como el Serial.println() con la excepción que Serial.println() inserta un retorno de carro y salta a la siguiente línea. Si algo se envia por el puerto serie con Serial.println(1) el mensaje se muestra en el monitor de la siguiente manera:

 1
 1
 1
 1

El avance de línea añadido por el Serial.println() es lo mismo que poner al mismo tiempo un final de linea y empezar en una nueva. Si queremos enviar Serial.print(1) través del puerto serie se recibiría como:

1111111111111111111111111111111111111

Tenga en cuenta que si está comunicandose con otros dispositivos electrónicos asegúrese de imprimir los datos en el formato correcto. A veces, el retorno de carro y salto de línea añadido por Serial.println() puede interferir con la comunicación. La información sobre el protocolo de comunicación adecuado para los distintos dispositivos electrónicos se pueden encontrar en la hoja de datos del dispositivo a comunicar.

  • Casos especiales de impresión

A veces será necesario enviar la información en diferentes formatos y entonces tiene que añadir este formato para su impresión:

Serial.println(message,format):

Los formatos disponibles son decimales, hexadecimal, octal, binario y bytes, y se utilizan como en los ejemplos siguientes:

Serial.print(b,DEC);
        /* Escribe 79 como código ASCII en decimal que es “79” */
Serial.print(b,HEX);
        /* Escribe 79 como código ASCII en hexadecimal que es “4F” */
Serial.print(b,OCT);
        /* Escribe 79 como código ASCII en octal que es “117” */
Serial.print(b,BIN);
        /* Escribe 79 como código ASCII en binario que es “1001111” */
Serial.print(b,BYTE);
        /* Escribe 79 como código ASCII en bytes que es
     “O” */

El ASCII (American Standard Code for Information Interchange) de codificación es una forma estándar de codificación de texto numérico. Cuando se escribe el número en su código, no está en realidad escribiendo el número, pero si el carácter representado los números, como "uno" es la palabra que representa 1.

Share