Qué es la programación con arduino y para qué sirve

Si entre tus inquietudes está descubrir qué es la

programación con arduino y para qué se
utiliza, acabas de llegar al lugar indicado para poner
fin a todas tus dudas. Y es que el arduino es nada
más y nada menos que una placa basada en un
microcontrolador, concretamente un ATMEL.
Pero, ¿qué es un microcontrolador? Se trata de una
plataforma de hardware libre. Cuenta con un
circuito integrado mediante el cual se pueden grabar
instrucciones. A su vez, estas instrucciones se
escriben usando un lenguaje de programación que
permite al usuario establecer programas que interactúan con circuitos electrónicos.
El arduino es una placa que tiene todos los elementos necesarios para conectar periféricos a las entradas y salidas de un
microcontrolador. Es decir, es una placa impresa con los componentes necesarios para que funcione el microcontrolador
y su comunicación con un ordenador a través de la comunicación serial.
¿Cómo funciona el Arduino?
Las funciones de Arduino, como ocurre con la mayoría de las placas de microcontroladores, se pueden resumir en 3
factores:
Cuenta con una interfaz de entrada. Esta puede estar directamente unida a los periféricos , o conectarse a ellos a través
de puertos.
La interfaz de entrada tiene como objetivo trasladar la información al microcontrolador. El microcontrolador es la pieza
que se encarga de procesar esos datos. Además, varía dependiendo de las necesidades del proyecto en el que se desee
usar la placa, y existe una gran variedad de fabricantes y versiones disponibles.
También cuenta con interfaz de salida. Este se encarga de llevar la información procesada a los periféricos autorizados de
hacer el uso final de esos datos. En algunos casos puede tratarse de otra placa en la que se centraliza y procesa la
información de forma totalmente renovada, o sencillamente, puede ser una pantalla o un altavoz encargado de mostrar
la versión final de los datos.
Lenguaje de la programación con Arduino: C++
¿Qué lenguaje utiliza este tipo de programación? La plataforma Arduino se programa con un lenguaje propio basado en
el lenguaje de programación de alto nivel Processing, lo que significa que es similar a C++.
¿Qué quiere decir esto? Que se trata de un lenguaje de programación de propósito general asociado a un sistema
operativo llamado UNIX.
Este lenguaje de medio nivel, trata con objetos básicos como caracteres, números, bits y direcciones de memoria, entre
otros.
Este tipo de lenguaje posee una gran portabilidad. Gracias a ello se suele utilizar para la programación de sistemas como
la construcción de intérpretes, compiladores, y editores de texto.

Se trata de una placa open hardware por lo que su diseño es de libre distribución y utilización, que incluso podemos
construirnos nosotros mismos (En la Figura 1 se observa el aspecto de la placa). En la siguiente web puede encontrarse
mucha información relativa a la placa:
 Figura 1. Aspecto de la placa Arduino Duemilanove.

El programa se implementará haciendo uso del entorno de programación propio de arduino y se transferirá empleando
un cable USB. Si bien en el caso de la placa USB no es preciso utilizar una fuente de alimentación externa, ya que el propio
cable USB la proporciona, para la realización de algunos de los experimentos prácticos sí que será necesario disponer de
una fuente de alimentación externa ya que la alimentación proporcionada por el USB puede no ser suficiente. El voltaje
de la fuente puede estar entre 6 y 25 Voltios.

Entorno de desarrollo

Para programar la placa es necesario descargarse de la página web de Arduino el entorno de desarrollo (IDE). Se dispone
de versiones para Windows y para MAC, así como las fuentes para compilarlas en LINUX. En la Figura 2 se muestra el
aspecto del entorno de programación. En el caso de disponer de una placa USB es necesario instalar los drivers FTDI. Estos
drivers vienen incluidos en el paquete de Arduino mencionado anteriormente. Existen en la web versiones para distintos
sistemas operativos.

Figura 2. Entorno de desarrollo.

Lo primero que tenemos que hacer para comenzar a trabajar con el entorno de desarrollo de arduino es configurar las
comunicaciones entre la placa Arduino y el PC. Para ello deberemos abrir en el menú "Tools" la opción "Serial Port". En
esta opción deberemos seleccionar el puerto serie al que está conectada nuestra placa. En Windows, si desconocemos el
puerto al que está conectado nuestra placa podemos descubrirlo a través del Administrador de dispositivos (Puertos COM
& LPT/ USB Serial Port).

El primer paso para comprobar que todo lo que hemos hecho hasta ahora está bien y familiarizarnos con el interfaz de
desarrollo, es abrir uno de los ejemplos. Se recomienda abrir el ejemplo "Blink". Para ello debemos acceder a través del
menú File ( Sketchbook ( Examples ( Digital ( Blink.

El ejemplo "Blink" lo único que hace es parpadear un LED que está colocado en el pin número 13 de la placa. Vamos a ver
qué hay que hacer para subir el programa a la placa Arduino. Primero comprobamos que el código fuente es el correcto.
Para ello pulsamos el botón de verificación de código que tiene forma de triángulo inclinado 90 grados (Figura 3.a). Si todo
va bien deberá aparecer un mensaje en la parte inferior de la interfaz indicando "Done compiling". Una vez que el código
ha sido verificado procederemos a cargarlo en la placa. Para ello tenemos que pulsar el botón de reset de la placa (Figura
3.b) e inmediatamente después pulsar el botón que comienza la carga (Figura 3.c).

Durante la carga del programa, en la placa USB, se encenderán los LED que indican que se están enviando y recibiendo
información por el puerto serie: TX/RX. Si todo se ha realizado correctamente debe aparecer el mensaje "Done uploading".
Ahora tan sólo queda esperar unos 8 segundos aproximadamente para comprobar que todo ha salido bien. Si el led
colocado en el pin 13 de la placa se enciende y se apaga cada segundo entonces todo ha ido bien. Por fin tenemos todo
listo para empezar a trabajar con la placa Arduino.

Figura 3. a) Compilar programa. b) Botón de reset. c) Transferir programa a la placa.

Estructura de un programa
La estructura básica del lenguaje de programación de Arduino es bastante simple y se compone de al menos dos partes.
Estas dos partes necesarias, o funciones, encierran bloques que contienen declaraciones, estamentos o instrucciones.
void setup() //Primera Parte
{
estamentos;
}
void loop() //Segunda Parte
{
estamentos;
}
En donde setup() es la parte encargada de recoger la configuración y loop() es la que contiene el programa que se
ejecutará cíclicamente (de ahí el término loop –bucle-). Ambas funciones son necesarias para que el programa trabaje.
La función de configuración (setup) debe contener la declaración de las variables. Es la primera función a ejecutar en el
programa, se ejecuta sólo una vez, y se utiliza para configurar o inicializar pinMode (modo de trabajo de las E/S),
configuración de la comunicación en serie y otras.
La función bucle (loop) siguiente contiene el código que se ejecutara continuamente (lectura de entradas, activación de
salidas, etc) Esta función es el núcleo de todos los programas de Arduino y la que realiza la mayor parte del trabajo.
setup()
La función setup() se invoca una sola vez cuando el programa empieza. Se utiliza para inicializar los modos de trabajo de
los pins, o el puerto serie. Debe ser incluido en un programa aunque no haya declaración que ejecutar. Así mismo se puede
utilizar para establecer el estado inicial de las salidas de la placa.
void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como salida
digitalWrite(pin, HIGH); // pone el ‘pin’ en estado HIGH
}
loop()
Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su nombre, se ejecuta de forma cíclica,
lo que posibilita que el programa esté respondiendo continuamente ante los eventos que se produzcan en la placa.
void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) el 'pin'
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el 'pin'
delay(1000);
}

Funciones
Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que son ejecutadas cuando se
llama a la función. Son funciones setup() y loop() de las que ya se ha hablado. Las funciones de usuario pueden ser escritas
para realizar tareas repetitivas y para reducir el tamaño de un programa. Las funciones se declaran asociadas a un tipo de
valor “type”. Este valor será el que devolverá la función, por ejemplo 'int' se utilizará cuando la función devuelve un dato
numérico de tipo entero. Si la función no devuelve ningún valor entonces se colocará delante la palabra “void”, que
significa “función vacía”. Después de declarar el tipo de dato que devuelve la función se debe escribir el nombre de la
función y entre paréntesis se escribirán, si es necesario, los parámetros que se deben pasar a la función para que se
ejecute.
type nombreFunción(parámetros)
{
instrucción;
}
La función siguiente devuelve un número entero, delayVal() se utiliza para poner un valor de retraso en un programa que
lee una variable analógica de un potenciómetro conectado a una entrada de Arduino. Al principio se declara como una
variable local, 'v' recoge el valor leído del potenciómetro que estará comprendido entre 0 y 1023, luego se divide el valor
por 4 para ajustarlo a un margen comprendido entre 0 y 255, finalmente se devuelve el valor 'v' y se retornaría al programa
principal. Esta función cuando se ejecuta devuelve el valor de tipo entero 'v'.
int delayVal()
{
int v; // crea una variable temporal 'v'
v= analogRead(pot); // lee el valor del potenciómetro
v /= 4; // convierte 0-1023 a 0-255
return v; // devuelve el valor final
}

{} entre llaves
Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se utilizan para los bloques de
programación setup(), loop(), if.., etc.
type funcion()
{

instrucciones;
}
Una llave de apertura “{“ siempre debe ir seguida de una llave de cierre “}”, si no es así el programa dará errores.
El entorno de programación de Arduino incluye una herramienta de gran utilidad para comprobar el total de llaves. Sólo
tienes que hacer click en el punto de inserción de una llave abierta e inmediatamente se marca el correspondiente cierre
de ese bloque (llave cerrada).

; punto y coma
El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de programación de Arduino. También se utiliza
para separar elementos en una instrucción de tipo “bucle for”.
int x = 13; /* declara la variable 'x' como tipo entero de valor 13 */

Nota: Olvidaos de poner fin a una línea con un punto y coma o se producirá en un error de compilación. El texto de error
puede ser obvio, y se referirá a la falta de una coma, o puede que no. Si se produce un error raro y de difícil detección lo
primero que debemos hacer es comprobar que los puntos y comas están colocados al final de las instrucciones.

/*… */ bloque de comentarios

Los bloques de comentarios, o comentarios multi-línea son áreas de texto ignorados por el programa que se utilizan para
las descripciones del código o comentarios que ayudan a comprender el programa. Comienzan con / * y terminan con * /
y pueden abarcar varias líneas.
/* esto es un bloque de comentario no se debe olvidar
cerrar los comentarios estos deben estar equilibrados */

Debido a que los comentarios son ignorados por el compilador y no ocupan espacio en la memoria de Arduino pueden ser
utilizados con generosidad. También pueden utilizarse para "comentar" bloques de código con el propósito de anotar
informaciones para depuración y hacerlo mas comprensible para cualquiera.
Nota: Dentro de una misma línea de un bloque de comentarios NO se puede escribir otro bloque de comentarios (usando
/*..*/).
// línea de comentarios
Una línea de comentario empieza con // y terminan con la siguiente línea de código. Al igual que los comentarios de
bloque, los de línea son ignoradas por el programa y no ocupan espacio en la memoria.
// esto es un comentario
Una línea de comentario se utiliza a menudo después de una instrucción, para proporcionar más información acerca de lo
que hace ésta o para recordarla más adelante.

Sentencias condicionales

El lenguaje de arduino permite realizar sentencias condicionales if, if... else, for, while, do... while. Su utilización es
similar a las funciones correspondientes en C.
Entradas y salidas digitales y analógicas

Función pinMode(pin, mode)

Función usada en la function setup() para configurar un pin dado para comportarse como INPUT o OUTPUT. Ej.
pinMode(pin, OUTPUT); configura el pin número 'pin' como de salida. Los pines de Arduino funcionan por defecto como
entradas, de forma que no necesitan declararse explícitamente como entradas empleando pinMode().

Función digitalRead(pin)
Lee el valor desde un pin digital específico. Devuelve un valor HIGH o LOW. El pin puede ser especificado con una variable
o una constante (0-13). Ej. v = digitalRead(Pin);

Funcion digitalWrite(pin, value)

Introduce un nivel alto (HIGH) o bajo (LOW) en el pin digital especificado. De nuevo, el pin puede ser especificado con una
variable o una constante 0-13. Ej. digitalWrite(pin, HIGH);

Función analogRead(pin)

Lee el valor desde el pin analógico especificado con una resolución de 10 bits. Esta función solo funciona en los pines
analógicos (0-5). El valor resultante es un entero de 0 a 1023. Los pines analógicos, a diferencia de los digitales no necesitan
declararse previamente como INPUT o OUTPUT.

Función analogWrite(pin, value)

Escribe un valor pseudo-analógico usando modulación por ancho de pulso (PWM) en un pin de salida marcado como
PWM. Esta función está activa para los pines 3, 5, 6, 9, 10, 11. Ej analogWrite(pin, v); // escribe 'v' en el 'pin' analógico.
Puede especificarse un valor de 0 - 255. Un valor 0 genera 0 V en el pin especificado y 255 genera 5 V. Para valores de 0 a
255, el pin alterna rápidamente entre 0 V y 5 V, cuanto mayor sea el valor, más a menudo el pin se encuentra en HIGH (5
V). Por ejemplo, un valor de 64 será 0 V tres cuartas partes del tiempo y 5 V una cuarta parte. Un valor de 128 será 0 V la
mitad del tiempo y 5 V la otra mitad. Un valor de 192 será 0 V una cuarta parte del tiempo y 5 V tres cuartas partes.

Funciones de tiempo y matemáticas

 delay(ms). Realiza una pausa en el programa la cantidad de tiempo en milisegundos especificada en el parámetro
(máximo 1000, mínimo 1).
 millis(). Devuelve la cantidad de milisegundos que lleva la placa Arduino ejecutando el programa actual como un
valor long unsigned. Después de de 9 horas el contador vuelve a 0.
 min(x,y). max(x,y). Devuelve el mínimo y el máximo respectivamente de entre sus parámetros.

Puerto serie

 Serial.begin(rate). Abre un Puerto serie y especifica la velocidad de transmisión. La velocidad típica para
comunicación con el ordenador es de 9600 aunque se pueden soportar otras velocidades.
 Serial.println(data). Imprime datos al puerto serie seguido por un retorno de línea automático. Este comando
tiene la misma forma que Serial.print() pero este último sin el salto de línea al final. Este comando puede
emplearse para realizar la depuración de programas. Para ello puede mandarse mensajes de depuración y valores
de variables por el puerto serie. Posteriormente, desde el entorno de programación de Arduino, activando el
"Serial Monitor" se puede observar el contenido del puerto serie, y, por lo tanto, los mensajes de depuración.
Para observar correctamente el contenido del puerto serie se debe tener en cuenta que el "Serial Monitor" y el
 puerto serie han de estar configurados a la misma velocidad (Para configurar la velocidad del puerto serie se hará
con el comando Serial.begin(rate)).
 Serial.read().Lee o captura un byte (un caracter) desde el puerto serie. Devuelve -1 si no hay ningún carácter en el
puerto serie.
 Serial.available(). Devuelve el número de caracteres disponibles para leer desde el puerto serie.

Desarrollo: Lo primero que hicimos antes de programar fue descargar el

programa arduino y un archivo adicional que se llama CH341SER
int m1=8;//atras izquierdo
int m2=9;//adelante izquierdo
int m3=10;//adelante derecho
Para que sea compatible con el programa si no instalaramos este
int m4=11;//atras izquierdo programa CH341SER nuestro programa arduino no detectaría la
entrada de nuestra laptop al arduino uno ya instalado todo estos
int infraPin1 = 2;
dos programas ahora si viene
int infraPin2 = 3;
int valorInfra1 = 0;
int valorInfra2 = 0;
const int Trigger =5;
const int Echo = 4;
const int Trigger1 = 7 ;
const int Echo1 = 6;

void setup() {
Serial.begin(9600);
pinMode(infraPin1, INPUT);
pinMode(infraPin2, INPUT);
pinMode(m1,OUTPUT);
pinMode(m2,OUTPUT);
pinMode(m3,OUTPUT);zzzzz
pinMode(m4,OUTPUT);
pinMode(Trigger, OUTPUT);
pinMode(Echo, INPUT);
digitalWrite(Trigger, LOW);
pinMode(Trigger, OUTPUT);
 pinMode(Echo, INPUT);
digitalWrite(Trigger, LOW);
}

void loop() {

long t; //timepo que demora en llegar el eco

long d; //distancia en centimetros

digitalWrite(Trigger, HIGH);
delayMicroseconds(10);
digitalWrite(Trigger, LOW);
t = pulseIn(Echo, HIGH);
d = t/59;
long t1;
long d1;
digitalWrite(Trigger1, HIGH);
delayMicroseconds(10);
digitalWrite(Trigger1, LOW);
t1 = pulseIn(Echo1, HIGH);
d1 = t1/59;
valorInfra1 = digitalRead(infraPin1);
valorInfra2 = digitalRead(infraPin2);

if((((d>30)&&(d1>30))&&((valorInfra1>0)&&(valorInfra2>0))))
{
digitalWrite(m1,HIGH);
digitalWrite(m2,HIGH);
digitalWrite(m3,HIGH);
digitalWrite(m4,LOW);
 }
else{
if((((d<30)&&(d1<30))&&((valorInfra1>0)&&(valorInfra2>0))))
{
digitalWrite(m1,HIGH);
digitalWrite(m2,LOW);
digitalWrite(m3,LOW);
digitalWrite(m4,HIGH);
}
else{
if((valorInfra1<1))
{
digitalWrite(m1,LOW);
digitalWrite(m2,HIGH);
digitalWrite(m3,HIGH);
digitalWrite(m4,LOW);

}
}

}
}