INTRODUCCION A LA

PROGRAMACION EN ARDUINO
PRINCIPIOS DE MECATRNICA
Que es un microcontrolador?
 Para que sirve un microcontrolador?

En una tpica casa en in pas desarrollado hay

alrededor de tres docenas de microcontroladores
Un tpico carro de gama media tiene mas de 30
microcontroladores.
Arduino Qu es?
 2001
Crea

2003
Crea

Hernando Barragn.

2005
Crea
 Software Arduino

Parecido a C
Basado en Wiring
Desarrollado en Java
Pensado para novatos
Librerias que amaras
 Elementos clave del lenguaje de
programacin
Estructura
Funciones
Sintaxis
Variables
Estructuras de control
Operadores de comparacin
Operadores booleanos
IF, WHILE, FOR
Operadores matemticos
Funciones especiales
 //declaracion de variables globales
int k;

//codigo que solo se ejecuta una vez

void setup(){
Serial.begin(9600);
}
Estructura de un Sketch //codigo que se ejecuta de forma ciclica
void loop(){
//variables locales
int i = 2;
int j = 3;
k = myMultiplyFunction(i,j);
Serial.println(k);
delay(500);
}

//Creacion de otras funciones

Int myMultiplyFunction(int x,int y){
int result;
result = x * y;
return result;
}
Funciones
 Sintaxis
conjunto de reglas que se deben seguir al escribir cualquier cdigo, de
tal manera que se pueda considerar correcto
 Variables
medio para nombrar y almacenar un valor para un posterior uso en el
programa

Antes de ser usada, toda variable tiene q ser declarada

Declarar una variable significa definir su tipo, y opcionalmente su valor
inicial
Una variable declarada dentro de una funcin solo podr ser usada por esa
funcin (variable local)
una variable declarada fuera de cualquier funcione podr ser usada por
todas las funciones (variable global)
El tipo de variable escogido determina la cantidad de espacio de memoria
que se destinara a almacenar el valor que se le asigne a la variable.
Declarar Variables
Para declarar una variable basta con indicar el tipo de variable seguida por el
nombre y opcionalmente el valor inicial, terminando con punto y coma (;) como se
muestra a continuacin.

int Valor1;
long Valor2 = 564;
boolean sense = false;
byte valor3;
Estructuras de control
Que controlan?
 Estructuras de control
Inicio Que controlan?
Dentro de
Declaraciones void loop(){
globales }
Instruccin 1

void setup(){
}
Instruccin 2

void loop(){
Instruccin 3
}
 Estructuras de control
Inicio Que controlan?
Dentro de IF-ELSE
Declaraciones void loop(){
globales } Instruccin
1

void setup(){ Falso

Verdadero
} Condicin

Instruccin Instruccin
2 3

void loop(){
}
Instruccin
4
 Estructuras de control
Inicio Que controlan?
Dentro de WHILE
Declaraciones void loop(){
globales } Instruccin
1

void setup(){ Falso

} Condicin

Verdadero
Instruccin
2
void loop(){
}
Instruccin
3
Operadores de comparacin
permiten determinar la relacin entre ciertos valores
tipo de retorno de los operadores de comparacin son de tipo
booleano true o false
Operadores booleanos
permiten establecer condiciones y comparaciones entre valores
booleanos (true y false)
normalmente se usan dentro de los condicionales de las estructuras
de control junto con los operadores de comparacin
Principales estructuras de control
if - evala una condicin dada y si esta se cumple (valor lgico true) se
ejecuta el cogido dentro del bucle.

if (CONDICIONAL) {
// Codigo que se ejecuta si se cumple la condicion
}
int Potenciometro = 0; // pin analogo al que se conecta el potenciometro
int Voltaje; // varaible en la que se almacena el volteje leido
int Luz = 12; //pin al que se conecta la luz a encender (LED, Bombilla...)
void setup(){
pinMode(Luz, OUTPUT); // define el pin como salida digital
}

void loop()
{
Voltaje = analogRead(Potenciometro); //lee el valor del potenciometro (0-1023)
Voltaje = map(Voltaje, 0, 1023, 0, 180); //escala en valor leido (valor entre 0 y 100)

if (Voltaje >= 90){ //evalua si el valor leido es mayor o igual a 90

digitalWrite(Luz, HIGH); //enciende la luz conectada al pin 12
}
if (Voltaje < 90) {
digitalWrite(Luz, LOW); //apaga la luz conectada al pin 12
}

}
Principales estructuras de control
if-else - evala una condicin y de cumplirse ejecuta un cdigo dado, pero
de no cumplirse ejecuta otro cdigo sin evaluar ms condicionales

if (CONDICIONAL){
// accin A
}
else
{
// accin B
}
int Potenciometro = 0; // pin analogo al que se conecta el potenciometro
int Voltaje; // varaible en la que se almacena el volteje leido
int Luz = 12; //pin al que se conecta la luz a encender (LED, Bombilla...)
void setup(){
pinMode(Luz, OUTPUT); // define el pin como salida digital
}

void loop() {
Voltaje = analogRead(Potenciometro); //lee el valor del potenciometro (0-1023)
Voltaje = map(Voltaje, 0, 1023, 0, 180); //escala el valor leido (valor entre 0 and 100)
if (Voltaje >= 90){ //evalua si el valor leido es mayor o igual a 90
digitalWrite(Luz, HIGH); //enciende la luz conectada al pin 12
}
else {
digitalWrite(Luz, LOW); //apaga la luz conectada al pin 12
}
}
Principales estructuras de control
if/else if/ else - evala una condicin y de cumplirse ejecuta un cdigo dado, pero
de no cumplirse evala otra condicin que de cumplirse ejecuta otro cdigo, si no
se cumple ejecuta otro cdigo sin evaluar ms condicionales

if (CONDICIONAL){
// accin A
}
Else if{
// accin B
}
else{
// accin C
}
Principales estructuras de control
while - si el condicional es verdadero, el cdigo interno se
ejecutara de manera continua hasta que el condicional se
haga falso

while(CONDICIONAL){
// Cdigo que se ejecutara de manera continua
}

Debe existir un variable que sea transformada dentro de while y evaluada en el condicional
//Declaracion de las variables donde se almacena los
pines
int Banda = 5;
int SensorCaja = 6;
int SensorJabon = 7;
int Motor = 8;

void setup() {
//Declaracion de el modo de cada pin
pinMode(Banda,OUTPUT);
pinMode(SensorCaja,INPUT);
pinMode(Motor,OUTPUT);
pinMode(SensorJabon,INPUT);
}
void loop() {
int conteo; //variable de conteo de jabones
boolean llenar; //varaible del sensor de cajas
boolean jabon; //variable para el sensor de jabon
digitalWrite(Banda,HIGH); //prender banda que mueve cajas
llenar = digitalRead(SensorCaja); //guardar lectura del sensor
if (llenar == HIGH){ // evaluar cuando hay caja en posicion
conteo = 0;
while(conteo<=5){
//este bucle se ejecutara hasta que se cuenten 5 jabones
digitalWrite(Banda,LOW); //apaga la banda
digitalWrite(Motor,HIGH); //prende el motor
jabon = digitalRead(SensorJabon);
if (jabon==HIGH){ // evalua cuando se detecta un jabon
conteo = conteo + 1; //suma un jabon al conteo
}
}
}
}
Principales estructuras de control
for - permite repetir un segmento de cdigo un nmero especfico
de veces. El cuerpo del for se ejecuta cero o ms veces hasta que un
condicional se hace falso
void setup() {
pinMode(3,OUTPUT); //Definicion de modo de pines
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void loop() {
int pin; //declaracion
pin = 3; //asignar 3 como valor inicial
for (pin;pin < 8; pin++) { //variable pin aumenta en uno hasta llegar a 8
digitalWrite(pin,HIGH); //enciende desde el pin 3 al 7 segn el valor de pin
delay(1000); //espera un segundo
}
}
 Operadores Matemticos
Operadores Aritmticos
Operadores Compuestos
Operadores trigonomtricos
Otros operadores
 Operadores Matemticos
Operadores Aritmticos:

int Valor;
Valor = 1 + 2; // suma
Valor = 3 - 2; // resta
Valor = 3 * 2; // multiplicacion
Valor = 3 / 2; // division (el resultado es 1 porque se definio Valor como entero)
 Operadores Matemticos
Operadores Aritmticos:

int value = 1 + 2 * 3 + 4;
 Operadores Matemticos
Operadores Aritmticos:

int value = 1 + 2 * 3 + 4;

Se debe tener en cuenta el orden de operacin. Las multiplicaciones y

divisiones son aplicadas primero que las sumas y restas, por lo cual el valor
de value ser de 11. Es una buena prctica usar parntesis para separar las
operacines como se muestra a continuacin:

int value = 1 + (2 * 3) + 4;
 Operadores Matemticos
Operadores Aritmticos:

Las operaciones tambin pueden realizarse entre variables y constantes y

entre variables y variables como se muestra a continuacin:

y = y + 3;
x = x - y;
i = 2 * y - x * 6;
r = r / 5;
 Operadores Matemticos
Operadores Compuestos:

Incrementar o disminuir el valor de una variable es una de las tareas ms

comunes en programacin

miValor = miValor + 1; // esto adiciona uno a la variable miValor

 Operadores Matemticos
Operadores Compuestos:

Incrementar o disminuir el valor de una variable es una de las tareas ms comunes en

programacin

miValor = miValor + 1; // esto adiciona uno a la variable miValor

en arduino es posible combinar el operador de suma con el operador de asignacin para

obtener un operador compuesto que realiza esta misma funcin como:

miValor += 1; // esto tambien adiciona uno a la variable miValor

 Operadores Matemticos
Operadores Compuestos:

x++; // incrementa x en uno y entrega el valor antiguo de x

++x; // incrementa x en uno y entrega el valor nuevo de x

x-- ; // disminuye x en uno y entrega el valor antiguo de x

--x ; // disminuye x en uno y entrega el valor nuevo de x

x += y; // equivalente a la expresin x = x + y;
x -= y; // equivalente a la expresin x = x - y;
x *= y; // equivalente a la expresin x = x * y;
x /= y; // equivalente a la expresin x = x / y;
 Operadores Matemticos
Operadores Compuestos:

Ejemplo:

int x;
x = 2;
x += 4; // x ahora es 6
x -= 3; // x ahora es 3
x *= 10; // x ahora es 30
x /= 2; // x ahora es 15
 Operadores Matemticos
Operadores trigonomtricos
Arduino cuenta con los operadores trigonomtricos bases seno, coseno y
tangente:

float deg = 30; // angulo en grados

float rad = deg * PI / 180; // convierte los grados en radianes
double pos1, pos2, pos3; //variables donde se asignaran los resultados
pos1 = sin(rad); //asigna el valor del seno de 2*pi (360 grados)
pos2 = cos(rad); // asigna el valor del coseno de pi (180 grados)
pos3 = tan(rad); //asigna el valor del seno de 2*pi (360 grados)
 Operadores Matemticos
Otros operadores
Funcin Descripcin Parmetros Retorno

x: primer numero, cualquier tipo

max (a,b) calcula el maximo entre dos numeros el mayor de los dos valores
y: segundo numero, cualquier tipo

x: primer numero, cualquier tipo

min (a,b) calcula el minimo entre dos numeros el menor de los dos valores
y: segundo numero, cualquier tipo

x: si x es mayor o igual a cero

abs (x) calucula el valor absoluto de un valor x: un numero
-x: si x es menor a cero

base: numero de tipo float

el resultado de la exponenciacion, debe ser de

pow (base, exponente) calcula el valor de un numero elevado a una potencia
exponente: potencia a la que se elevara la base, debe ser tipo tipo double
float

la raiz cuadrada del numero, debe ser tipo

sqrt (x) calcula la raiz cuadrada de un numero x: numero de cualquier tipo
double

x: el numero a restrisgir x: si x esta entre a y b

contrain(x, a, b ) restringe un numero a estar entre un rango a: el limite inferior del rango a: si x es menor que a

b: el limete superior del rango b: si x es mayor que b

ENTRADAS Y SALIDAS DIGITALES
Entrando al mundo microcontrolado
 Definicin del modo de operacin de los
pines digitales

La tarjeta Arduino UNO cuenta con 14 pines que pueden ser

configurados como entradas y salidas digitales (del pin 0 al pin 13).
Para poder usar estos pines lo primero es indicar como van a ser
usados, es decir, declarar si el pin ser usado como salida o como
entrada digital
Para realizar esta declaracin, se usa la funcin pinMode()
int entrada1 = 12;
//declara la variable entrada1 con el valor 12 que corresponder al nmero del pin
int salida1 = 11;
//declara la variable salida1 con el valor 11 que corresponder al nmero del pin
void setup() {

pinMode(salida1, OUTPUT); // Establece el pin 11 como pin de salida

pinMode(entrada1, INPUT); // Establece el pin 12 como pin de entrada

void loop() {
//codigo que sera ejecutado ciclicamente
}
 Funciones de lectura y escritura sobre los
pines digitales

A diferencia de la programacin en C para microcontroladores en la que

es necesario utilizar algebra booleana para cambiar el estado de los bit de
cada registro del microcontrolador (GRAN GRAN VENTAJA!!!)
El proceso de activar y desactivar una salida digital y conocer el estado de
una entrada se realiza por medio de las funciones digitalWrite( ) y
digitalRead( ).
 Funciones de lectura y escritura sobre los
pines digitales

La funcin digitalWrite( ) contiene dos parmetros, el primero es

el nmero del pin sobre el que se desea escribir y el segundo es el valor
lgico que se va a escribir en ese pin

Los valor lgico debe ser:

HIGH para un 1 lgico, es decir, activar la salida (5V)
o
LOW para un cero lgico, es decir, desactivar la salida
int led = 13; //declara en la variable led el numero del pin

void setup() {
pinMode(led, OUTPUT); // establece el pin 13 como pin de salida
}

void loop() { // el bucle loop se repite una y otra ves

digitalWrite(led, HIGH); // enciende el led (HIGH indica un 1 logico /5 V)
delay(1000); // espera un segundo
digitalWrite(led, LOW); // apaga el led (LOW indica un 0 logico/ 0 V)
delay(1000); // espera un segundo
}

El mismo resultado se obtendra si se escribiera el numero 13 directamente dentro de la funcin digitalWrite( ).

 Funciones de lectura y escritura sobre los
pines digitales

La funcin digitalRead( ) contiene un solo parmetro

correspondiente el nmero del pin que se desea leer
entrega en retorno el valor ledo en ese pin (HIGH o LOW)
se debe almacenar este retorno en una variable para poder usarlo
posteriormente
Nota importante antes de seguir con ejemplos de entradas digitales:

'Just because you have nothing at all connected to an input pin doesn't
mean it is a logical zero.'
Resistencias PullUp y PullDown
PullUp Interna en Arduino

pinMode(2,INPUT_PULLUP);
 void setup() {
Serial.begin(9600);
pinMode(2, INPUT_PULLUP);
pinMode(13, OUTPUT);
}
void loop() {
int sensorVal = digitalRead(2);
Serial.println(sensorVal);

if (sensorVal == HIGH) {
digitalWrite(13, LOW);
} else {
digitalWrite(13, HIGH);
}
}
Ejemplo con PullUp externo
Ejemplo con PullUp externo
Ejemplo con PullUp externo
const int buttonPin = 2;
const int ledPin = 13;

int buttonState = 0;

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}

void loop() {

buttonState = digitalRead(buttonPin);

if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
}
else {

digitalWrite(ledPin, LOW);
}
}
Primera practica
1. Hacer que 5 leds prendan en secuencia (uno despus del otro en
orden) con un delay inicial de 1000 ms
2. Al presionar un pulsador la direccin de la secuencia debe cambiar
3. Con otro pulsador se debe hacer cambiar la velocidad de la
secuencia, aumentando el delay en 100 ms
4. Con un tercer pulsador se debe hacer cambiar la velocidad de la
secuencia, disminuyendo el delay en 100 ms