Microcontroladores MKT - Unidad II

MICROCONTROLADORES
UNIDAD II
Programación de entradas y salidas
del microcontrolador.
INGENIERÍA MECATRÓNICA
Culiacán, Sinaloa Septiembre 2020

2. Programación de entradas y salidas del
microcontrolador.
COMPETENCIA ESPECIFICA A DESAROLLAR
Desarrolla aplicaciones para el manejo automático de diversos

dispositivos, mediante la programación de los puertos de entrada y
salida de un microcontrolador.
microcontrolador.
Introducción
 Un programa codificado en lenguaje C resulta muy útil en la

aplicación de microcontroladores, dado que su compilación es
bastante eficiente y óptima acercándose a la codificación de lenguaje
de máquina.
 Lo descriptivo de la sintaxis permite elaborar de mejor forma los

algoritmos olvidándose de los molestos push y pop usados en el
lenguaje de máquina cuando se usan saltos a subrutinas.
microcontrolador.
Introducción
Estructura básica de un programa en C
La estructura de un programa básico en lenguaje C se indica en el
esquema, el cual muestra un bloque principal llamado main() y bloques
de funciones. Puede ser que solo se requiera del bloque principal,
dependiendo de la aplicación.
microcontrolador.
Introducción
Elementos básicos:
 Comentario, este permite la documentación del código y se usa de
acuerdo a la siguiente sintaxis
/* Este es un comentario */ o // Este es un comentario
 Inicio y fin de bloque, permite agrupar un número de instrucciones

las que pueden ser ejecutadas con cierta prioridad. Se usa { para
iniciar bloque y } para finalizar bloque.
{ // inicio de bloque
// instrucciones
} // final de bloque
microcontrolador.
Introducción
Elementos básicos…
 Identificador, es el nombre que se le da a una variable o función por
lo general asociado al tipo de dato que ha de contener la variable o al
tipo de procedimiento que ha de realizar la función. Tipo, es una
palabra reservada definida que indica el tipo de variable que se ha
de definir y su alcance numérico, esto de acuerdo a la Tabla.
microcontrolador.
Introducción
 Identificador,…
Así, la definición de las variables se hace usando el tipo y un
identificador que da el nombre de la variable finalizado por un ; (punto y
coma). También puede definir varias variables con un solo tipo. En esta
caso son separadas por , (coma) pero siempre se finaliza con ; (punto y
coma).
char i; // define variable tipo char de 8 bits
char j,i;
float x,r; // define variables de tipo punto flotante de 16 bits
long a,b,c,d; // define variables de tipo punto flotante de 32 bits
int i,j; // define dos variables de tipo enteros
microcontrolador.
Introducción
 Palabra reservada, es un identificador usado por el lenguaje de
programación para describir algo especial. Es usado para describir el
tipo de un objeto o dentro de una función para describir la ejecución
de una sentencia.
Una palabra reservada no puede ser usada como nombre de objeto,
se escriben en minúsculas, aunque no es buena practica declarar
estas palabras como nombres.
Las palabras reservadas son:
auto double int struct break else long switch case enum
register typedef char extern return union const float short
unsigned continue for signed void default goto sizeof volatile
do if static while …
microcontrolador.
Introducción
 Constantes, es usada para describir un valor numérico o una
cadena de caracteres, las constantes numéricas pueden ser
expresadas como constantes reales, enteras o de carácter.
Las constantes enteras pueden ser expresadas en base decimal,
binaria, octal o hexadecimal.
Ejemplo:
char c;
void main()
{
c=0x31; // en hexadecimal
c=49; // en decimal
c=’1’; // en carácter
}
microcontrolador.
Introducción
 Operadores y signos de puntuación, un operador es usado para describir una
operación aplicada a uno o varios objetos. Los operadores son usados en
muchas expresiones y en diversos tipos de declaraciones. Los operadores
consisten en una secuencia de caracteres no-alfanuméricos (uno o dos).
Pueden ser: Aritméticos (+), Booleanos (&), de Comparación (>), de
Desplazamiento (>>), Manejo de apuntadores (->), Compilación (#), Paréntesis-
Corchetes ({ }).
Operadores Aritméticos: Operadores Lógicos:
char i,j, k; char i,j, k;
void main() void main()
{ {
i=10; k=i&j; // operación AND entre i y j bit a bit
j=20; k=i|j; // operación OR entre i y j bit a bit
k=i+j; //suma de 2 enteros k=~i; // operación negación de i asignado a
k=i-j; // resta de 2 enteros k
k=i*j; // multiplicación de 2 enteros k=i<<1; // i desplazado en un bit a izquierda
k=i%j; // Division entera (debe dar el k=i<<2; // i desplazado en 2 bit a izquierda
resto) k=i>>1; // i desplazado en un bit a la derecha
k++; // incremento k=k+1 k=i<<2; // i desplazado en 2 bit a la derecha
k--; // decremento k=k-1; }
}
microcontrolador.
Introducción
 Un signo de puntuación se usa para separar o terminar una lista de
elementos.
Pueden ser: Punto y coma (;), Dos puntos (:) y Coma (,)
Operadores Símbolos
Aritméticos + - * / % = += -= *= /= ++ --
Booleanos & | ~ ˆ == && || |= &= != ? ! ˆ=
De Comparación > < >= <=
De Desplazamiento >> << <<= >>=
Manejo de apuntadores -> & * .
Paréntesis y Corchetes []{}()
Puntuación ;:,
Compilación y Declaración # ##
microcontrolador.
Introducción
Instrucciones básicas
Estos son los elementos más básicos para la generación de un programa,

se considera: asignación, operaciones matemáticas, operaciones lógicas.
 Asignaciones: Consiste en asignarle un valor a una determinada

variable. En el ejemplo se declaran dos variables de 8 bits y luego se
le asignan los valores respectivos.
char i, j; // Declaración de variables

void main()
{
i=10;
j=20;
}
microcontrolador.
Introducción
 Asignaciones…
Los valores asignados a las variables tipo char o int pueden tener
distintos formatos ya sea decimal, octal, hexadecimal o binario. Esto
es muy útil dado que en el más bajo nivel siempre se trabaja en
binario.
 Independencia de la representación. A nivel de un µControlador, todas las
instrucciones de trabajan en binario, por lo tanto, los datos también, es
decir, se puede representar un valor en un formato numérico, ya sea
hexadecimal, decimal o tipo carácter, pero a bajo nivel es siempre
binario.
Por ejemplo, sea la variable dato, la cual se le asigna el valor 49. Este
valor será almacenado en memoria en formato binario como 00110001, lo
que representado en formato hexadecimal corresponde al 31H.
microcontrolador.
Introducción
 Asignaciones…
 Independencia de la representación…
void main() dato
{
char dato; 0 0 1 1 0 0 0 1
dato=49;
}
En el caso de trabajar con 16 bit, el formato hexadecimal quedará 0x0031.
 Formatos de asignación: La asignación puede ser hecha en decimal,

hexadecimal, binario o carácter (si es que se conoce).
microcontrolador.
Introducción
 Operaciones Matemáticas: Se tienen la suma, resta, multiplicación
y división, división entera más las operaciones de incremento y
decremento.
char i,j,k;
void main()
{
i=10;
j=20;
k=i+j; // suma de 2 enteros
k=i-j; // resta de 2 enteros
k=i*j; // multiplicación de 2 enteros
k=i%j; // división entera (debe dar el resto)
k++; // incremento k=k+1
k--; // decremento k=k-1
}
microcontrolador.
Introducción
 Operaciones Lógicas: Se realizan con variables enteras y afectan

directamente al bit del dato, se tienen los operadores lógicos y los
desplazamientos a la Izquierda y a la derecha.
char i,j, k;
void main()
{
k=i&j; // operación AND entre i y j bit a bit
k=i|j; // operación OR entre i y j bit a bit
k=~i; // operación negación de i asignado a k
k=i<<1; // i desplazado en un bit a izquierda
k=i<<2; // i desplazado en 2 bit a izquierda
k=i>>1; // i desplazado en un bit a la derecha
k=i>>2; // i desplazado en 2 bit a la derecha
}
microcontrolador.
Introducción
Sentencias de control
Permiten definir las funciones a ejecutar dependiendo de ciertas condiciones que

se deben evaluar. Estas condiciones pueden ser tipo lógicas, tipo mayor, menor o
igual o ambas. Por lo general se agrupan entre paréntesis para definir la
prioridad de la evaluación de la condición.
La condición verdadera puede ser también de la siguiente forma: Si se quiere

preguntar por una variable que es mayor que cero solo se coloca la variable si se
quiere preguntar si es falsa entonces se niega, usando el operador !.
microcontrolador.
Introducción
Sentencia if-else
Puede usarse el if solo o el if-else. Si la condición es verdadera

entonces se ejecuta una instrucción o un grupo de instrucciones en
caso contrario se ejecuta la que sigue.
char i,j,k,h;
void main()
{
i=10;
j=20;
if(i==j) k=1; // si i=j entonces k=1, sino k=2
else k=2;
}
microcontrolador.
Introducción
Sentencia if-else…
Otros ejemplos:
char i,j,k,h;
void main()
{
i=10;
j=20;
if(i==10) // si i=10 entonces k=20, j=10, sino k=40, j=20, h=60
{
k=20;
j=10;
}
else
{
k=40;
j=20;
h=k+j;
}
}
microcontrolador.
Introducción
Sentencia if-else…
Otros ejemplos:
char i,j,k;
void main()
{
i=10;
j=20;
if((i==10) && (j==20)) // Si i=10 y j=20 entonces...
{
k=20;
j=10;
}
if(i) i=0; // si i es mayor que cero
if(!i) i=30; // si i es cero
}
microcontrolador.
Introducción
Sentencia while( )
Esta evalúa la condición al inicio, si ésta es verdadera, entonces se ejecuta
el bloque que viene a continuación en caso contrario lo salta.
El formato es el siguiente:
while(condición) instrucción;
while(condición)
{
instrucción_1;
...
instrucción_n;
}
microcontrolador.
Introducción
Sentencia while( )…
En el siguiente código fuente se muestra que el ciclo while se realiza ya que i
siempre sea mayor que 0. Sin embargo en algún momento i será menor que 0,
dado que k se va decrementando y se hace igual a i dentro del ciclo.
char i,j,k,h;
void main()
{
i=1; k=2; j=3;
while(i>0) // Solo mientras i>0 hace lo que viene a continuación
{
h=k+j;
k--;
i=k;
}
}
microcontrolador.
Introducción
En el ejemplo sólo se evalúa la condición verdadera, pero nunca sale del ciclo.
char i,j,k,h;
void main()
{
i=1;
while(i) // Se usa while(1), solo mientras i mayor que cero hace lo
siguiente
{
k=40;
j=20;
h=k+j;
}
}
microcontrolador.
Introducción
Para salir de un ciclo donde no existe posibilidad de que la condición sea alterada,
se puede usar la sentencia break.
char i,j,k,h;
void main()
{
i=0;
while(1)
{
i++;
if(i==5) break; // Sale cuando i=5
}
}
La instrucción de salto break se usa para interrumpir (romper) la ejecución normal de un
bucle, es decir, la instrucción break finaliza (termina) la ejecución de un bucle y, por tanto,
el control del programa se transfiere (salta) a la primera instrucción después del bucle.
microcontrolador.
Introducción
La sentencia do-while es una variación de la sentencia while, pero en ésta se
evalúa la condición al final, por ejemplo “Hágalo mientras se cumpla la
condición”.
void main()
{
char i;
i=10;
do
{
i--;
}
while(i!=5); // Sale cuando i=5
}
microcontrolador.
Introducción
Sentencia switch - case
La instrucción switch - case se usa cuando se deben seleccionar entre varias
opciones tipo numéricas; es básicamente un selector. Ejemplo:
char c;
void main()
{
c=1;
switch(c)
{
case 1: c++; break;
case 2: c++; break;
case 3: c++; break;
default: break;
}
}
Si el valor que toma la variable no coincide con los valores especificados en los casos, se
realizarán las acciones definidas en la etiqueta default.
microcontrolador.
Introducción
Sentencia for
Permite el uso de los clásicos ciclos for. El formato es el siguiente:
for(expr_1;expr_2;expr_3) instrucción; for(expr_1;expr_2;expr_3)
{
instrucción_1;
instrucción_n;
}
microcontrolador.
Introducción
Sentencia for…
Hacer un programa que cuente los números enteros pares que hay de
0 a 100:
char i, contador;
Void main( )
{
contador=0;
for(i=1; i<=100; i++)
{
if(i%2==0)
{
contador++;
}
}
}
microcontrolador.
Introducción
Sentencia for…
Hacer un programa que muestre cuántos números enteros múltiplos
de 5 hay hasta el 50:
char i, contador;
Void main( )
{
contador=0;
for(i=1; i<=50; i++)
{
if((i>0)&&(i%5==0))
{
contador++;
}
}
}
microcontrolador.
Introducción
Funciones y Llamados a funciones
Las funciones permiten agrupar código y optimizar el tamaño de éste. Se

tienen distintos tipos de funciones:
 Las que solo ejecutan tareas y no devuelven valor.

void activar_sensores(); // Declaración
 Las que ejecutan y devuelven un valor.

char lee_sensores(); // Declaración
 Las que reciben parámetros y no devuelven.

void activa_motor(char num_motor); // Declaración
 Las que reciben parámetros y devuelven información.

char enviar(char dato); // Declaración
microcontrolador.
Introducción
Funciones y Llamados a funciones…

 El traspaso de información a una función se realiza a través de sus argumentos.
Por lo general se conoce como paso de parámetros por valor, esto quiere decir
que se puede pasar el número o dato en forma explícita o a través de una
variable.
 Cuando el valor se pasa a través de alguna variable, si el contenido de ésta es

modificado en el interior de la función, el valor de la variable fuera de la función
no es modificado.
 El paso de parámetros por referencia solo se puede realizar usando punteros, en

este caso, si el dato es pasado mediante una variable a la función, y éste es
modificado al interior de ella, su modificación se verá reflejada fuera de la
función. El uso de punteros en este caso como argumento permite manejar dicha
situación, ya que lo que se está transfiriendo a la función es la dirección donde se
encuentra el dato.
microcontrolador.
Introducción
 Las que solo ejecutan tareas y no devuelven valor.
Estas funciones son identificadas con un nombre de acuerdo a la tarea que realizan. Sin
embargo, el identificador de las funciones lleva paréntesis (). Las funciones que no devuelven
valor son declaradas usando la palabra void junto al nombre de ésta, los paréntesis y el punto
y coma(;).
Son llamadas directamente a través del nombre o identificador correspondiente. La siguiente

función es llamada desde el programa principal no recibe argumento ni tampoco retorna un
valor.
void suma(); // Declaración
void main() void suma() // Definición de la función
{ {
suma(); // llamada char i,j,sum;
} i=10;
j=20;
sum=i+j;
}
microcontrolador.
Introducción
 Las que ejecutan y devuelven un valor.
Las que devuelven valor deben ser llamadas a través de una asignación, en donde el
nombre de la función es asignado a una variable que recibirá el resultado devuelto
por la función. La función en este caso debe ser declarada (o definida)
considerando el tipo de valor que ha de retornar o devolver. La siguiente función es
declarada tipo char, retorna el valor correspondiente, por lo tanto al ser llamada, la
función inmediatamente debe ser asignada a una variable del mismo tipo a ser
retornada.
char suma(); // Declaración

char suma() // Definición de la
función
void main() {
{ char i,j,k;
char resultado; i=10;
resultado=suma(); // Llamada j=20;
} k=i+j;
return(k);
microcontrolador.
Introducción
 Las que reciben parámetros y no devuelven.
Para el paso de los argumentos, estos son definidos entre los paréntesis de la función
considerando el tipo de la variable requerida. La siguiente función recibe un parámetro
tipo char por valor y no retorna valor.
void suma(char i); // Declaración
char h;
void main() void suma(char i) // Definición de la función
{ {
h=10; char j,k;
suma(h); // Llamada j=20;
} k=i+j;
}
2 Programación de entradas y salidas del
microcontrolador.
Introducción
 Las que reciben parámetros y devuelven información.
Aquí, una función recibe parámetros y retorna un valor. El valor retornado a su vez
puede ser usado por una sentencia de control para tomar alguna decisión.
char suma(char i,j); // Declaración

void main()
{ char suma(char i,j) // Definición de la
función
char k,l,res; {
l=1; char h;
k=1; h=i+j;
while(1) return(h);
{ }
res=suma(k,l); // Llamada
if (res==5) break;
k++;
}
microcontrolador.
2.1 Arquitectura de los puertos de E/S.
Arduino es una plataforma de prototipos electrónica de código abierto (open-

source) basada en hardware y software flexibles y fáciles de usar. Está pensado
para artistas, diseñadores, como hobby y para cualquiera interesado en crear
objetos o entornos interactivos.
Arduino puede “sentir” el entorno mediante la recepción de entradas desde una

variedad de sensores y puede afectar a su alrededor mediante el control de
luces, motores y otros artefactos. El microcontrolador de la placa se programa
usando el Arduino Programming Language (basado en Wiring) y el Arduino
Development Environment (basado en Processing). Los proyectos de Arduino
pueden ser autonomos o se pueden comunicar con software en ejecución en un
ordenador.
microcontrolador.
El modulo Arduino/Genuino Uno es una placa

de microcontrolador basada en el uCC
ATmega328P. Este sistema presenta la
siguiente arquitectura, como se muestra en
la figura:
 Tiene 14 pines de entrada/salida digitales

(de los cuales 6 pueden utilizarse como
salidas PWM)
 6 entradas analógicas
 Un cristal de cuarzo de 16 MHz
 Conexión USB
 Un encabezado ICSP
microcontrolador.
En la figura se muestra la distribución de los pines del microcontrolador
ATMega328P, relacionada con los pines funcionales de la placa de Arduino
UNO R3.
microcontrolador.
microcontrolador.
microcontrolador.
2.2 Configuración y características eléctricas de los puertos de
E/S.
ENTRADAS Y SALIDAS DIGITALES
La placa Arduino dispone de 14 pines-hembra de entradas o salidas
digitales, numeradas desde la 0 hasta la 13; donde conectaremos los
sensores para que la placa pueda recibir datos del entorno, y también donde
conectaremos los actuadores para que la placa pueda enviarles las órdenes
pertinentes. A veces a estos pines-hembra digitales de “propósito general”
se les llama pines GPIO (de “General Purpose Input/Output”).
Todos estos pines-hembra digitales funcionan a 5 V, pueden proveer o

recibir un máximo de 40 mA y disponen de una resistencia “pull-up” interna
de entre 20 KΩ y 50 KΩ que inicialmente está desconectada (salvo que
nosotros indiquemos lo contrario mediante programación software).
2. Programación de entradas y salidas del microcontrolador.
2.2 Configuración y características eléctricas de los puertos de E/S.
CONFIGURACIÓN DE LAS ENTRADAS Y SALIDAS DIGITALES
Las funciones que nos ofrece el lenguaje Arduino para trabajar con entradas y
salidas digitales son:
 pinMode(): Configura un pin digital (el número se especifica como primer

parámetro) como entrada o como salida de corriente, según si el valor de su
segundo parámetro es la constante predefinida INPUT o bien OUTPUT,
respectivamente. Los pines digitales pueden actuar como entrada o salida, pero
en el sketch hay que definirlo dentro de setup(). No tiene valor de retorno.
Ejemplo: pinMode(1, OUTPUT)
 digitalWrite(): Envía un valor ALTO (HIGH) o BAJO (LOW) a un pin digital; es
decir, solo envia dos valores posibles. Por eso, se habla de salida “digital”. El #
de pin al que se le envía la señal se especifica como primer parámetro y el valor
concreto de esta señal se especifica como segundo parámetro (escribiendo la
constante HIGH o LOW, ambas de tipo “int”). Ejemplo: digitalWrite(1, HIGH)
microcontrolador.
E/S.
CONFIGURACIÓN DE LAS ENTRADAS Y SALIDAS DIGITALES…

 digitalRead(): Devuelve el valor leído del pin digital (configurado como entrada
mediante pinMode(#,INPUT)) cuyo número se haya especificado como
parámetro. Este valor de retorno es de tipo “int” y puede tener dos únicos
valores (por eso, de hecho hablamos de entrada digital): la constante HIGH (1) o
LOW (0). Ejemplo: int ValorPin=digitalRead(8);
 pulseIn(): Pausa la ejecución del sketch y espera a recibir en el pin de entrada

especificado como primer parámetro la señal HIGH o LOW (según lo indicado
como segundo parámetro). Una vez recibida esa señal, empieza a contar los µseg
que dura hasta cambiar su estado otra vez, y devuelve finalmente un valor (tipo
long) correspondiente a la duración en µseg del pulso de señal. Ejemplo:
tiempo=pulseIn(8, LOW);
USO DE LAS ENTRADAS Y SALIDAS DIGITALES...
Ejemplos con salidas digitales:
1. La idea es encender y apagar un LED de forma periódica simplemente. El circuito

montado en la protoboard será el siguiente: R=220Ω
Programa en
ambiente Arduino
“LED On-Off”
microcontrolador.
E/S.
2. Implementar un semáforo que encienda la siguiente secuencia: Luz roja (6

segundos), Luz ámbar (3 segundos) y Luz verde (6 segundos)… así sucesivamente.
Realizarlo mediante los pines 11,12 y 13 como salidas digitales.
Programa en
ambiente Arduino
“Semáforo”
microcontrolador.
E/S.
3. Realizar un SKETCH que modifique el programa anterior seleccionando un pin de

entrada y que su estado defina si es LOW encienda y apague los tres LEDs por 1.5
segundos, si es HIGH como semáforo con la misma secuencia del anterior. Realizarlo
mediante los pines 11,12 y 13 como salidas digitales; y el pin 8 como entrada digital.
Programa en ambiente
Arduino “Selector
semáforo”
microcontrolador.
E/S.
Las Entradas Analógicas

 La placa Arduino UNO R3 dispone de 6 entradas analógicas (en forma de pines-
hembra etiquetados como “A0”, “A1”... hasta “A5”) que pueden recibir voltajes
dentro de un rango de valores continuos de entre 0 y 5V.
 No obstante, la electrónica interna de la placa tan solo puede trabajar con

valores digitales, por lo que es necesaria una conversión previa del valor
analógico recibido a un valor digital lo más aproximado posible. Ésta se realiza
mediante un circuito conversor analógico/digital incorporado en la propia placa.
 El circuito conversor es de 6 canales (uno por cada entrada) y cada canal dispone
de 10 bits (los llamados “bits de resolución”) para guardar el valor del voltaje
convertido digitalmente.
microcontrolador.
2.2 Configuración y características eléctricas de los puertos
de E/S.
Las Entradas Analógicas…

 En general, la cantidad de bits de resolución que tiene un determinado
conversor analógico/digital es lo que marca en gran medida el grado de
precisión conseguida en la conversión de señal analógica a digital, ya que
cuantos más bits de resolución tenga, más fiel será la transformación.
Por ejemplo, en el caso del conversor en la placa Arduino, hay un máximo de

1024 valores diferentes posibles. Por tanto, el Arduino puede distinguir para el
voltaje digital desde el valor 0 hasta el valor 1023. Cada valor digital
corresponde a una “ventana” analógica de aproximadamente 5V/1024 ≈ 5mV.
Todos los valores analógicos dentro de cada rango de 5mV (desde 0 a 5 V) se

“colapsan” sin distinción en un único valor digital (desde 0 a 1023). Así pues,
no podremos distinguir valores analógicos distanciados por menos de 5 mV.
microcontrolador.
de E/S.
Las funciones que sirven para gestionar entradas analógicas son las siguientes:
 analogRead(): Devuelve el valor leído del pin de entrada analógico cuyo número
(0, 1, 2...) se ha especificado como parámetro. Este valor se obtiene mapeando
proporcionalmente la entrada analógica obtenida (que debe oscilar entre 0 y un
voltaje llamado voltaje de referencia, el cual por defecto es 5V) a un valor
entero entre 0 y 1023. Esto implica que la resolución de lectura es de 5V/1024,
es decir, de 0,049 V. Ejemplo: Valor=analogRead(0);
 analogReference(): Es posible aumentar la resolución de lectura si se reduce el

voltaje de referencia con esta función; configura el voltaje de referencia usado
por las entradas analógicas (rango de entrada mayor). Las opciones son:
 DEFAULT: the default analog reference of 5 volts (on 5V Arduino boards) or
3.3 volts (on 3.3V Arduino boards)
microcontrolador.
de E/S.
 analogReference()…
 INTERNAL: an built-in reference, equal to 1.1 volts ATmega328
 INTERNAL1V1: a built-in 1.1V reference (Arduino Mega only)
 INTERNAL2V56: a built-in 2.56V reference (Arduino Mega only)
 EXTERNAL: the voltage applied to the AREF pin (0 to 5V only) is used as the
reference.
Su sintaxis es la siguiente: analogReference(type), el parámetro son las opciones antes

mencionadas. Ejemplo: analogReference(INTERNAL);
Nota: El Pin AREF ofrece un voltaje de referencia externo para poder aumentar la precisión de las
entradas analógicas.
Programa “Pot_Analog”
Programa “PT100_Analog”
microcontrolador.
de E/S.
 Por último, decir que estos pines-hembra de entrada analógica tienen
también toda la funcionalidad de los pines de entrada-salida digitales.
Es decir, que si en algún momento necesitamos más pines-hembra digitales más

allá de los 14 que la placa Arduino ofrece (del 0 al 13), los 6 pines-hembra
analógicos pueden ser usados como unos pines-hembra digitales más
(numerándose entonces del 14 al 19) sin ninguna distinción.
 Por otro lado, hay que saber que el convertidor analógico/digital tarda
alrededor de 100 microsegundos (0,0001s) en procesar la conversión y
obtener el valor digital, por lo que el ritmo máximo de lectura en los
pines analógicos es de 10000 veces por segundo. Esto hay que tenerlo en
cuenta en los sketches
microcontrolador.
de E/S.

Ejemplo:
Desarrollar un termómetro con un sensor LM35, que tiene una sensibilidad de
10mV/°C, el voltaje de salida del sensor es una señal analógica que debe
procesarse veces mediante un algoritmo para representar la temperatura
medida, el programa debe visualizar los valores de la variable física. Además,
en la salida debe encender un LED cuando exceda los 32°C y desplegar el
mensaje “Temperatura alta”; apagarlo cuando baje de los 28°C y desplegar el
mensaje “Temperatura baja”; cuando la temperatura esté entre estos valores
desplegar el mensaje “Temperatura intermedia”.
“Temp_LM35”
microcontrolador.
de E/S.
Las Salidas Analógicas (PWM)
 En los proyectos a desarrollar con µCC se necesitará enviar señales analógicas hacia
al entorno, por ejemplo, para variar progresivamente la velocidad de un motor, la
frecuencia de un sonido emitido por un zumbador o la intensidad con la que luce
un LED.
 No basta con simples señales digitales: tenemos que generar señales que varíen
continuamente. La placa Arduino no dispone de pines-hembra de salida analógica
propiamente dichos (porque la arquitectura interna no tiene un convertidor digital-
analógico), sino que utiliza algunos pines-hembra de salida digitales concretos para
“simular” un comportamiento analógico.
 Los pines-hembra digitales que son capaces trabajar en este modo no son todos:
solo son los marcados con la etiqueta “PWM”. En concreto para el modelo Arduino
UNO son los pines número: 3, 5, 6, 9, 10 y 11.
microcontrolador.
de E/S.
Las Salidas Analógicas (PWM)…
 Las siglas PWM significa Modulación de
Ancho de Pulso. Lo que hace este tipo de
señal es emitir, en lugar de una señal
continua, una señal cuadrada formada por
pulsos de frecuencia constante
(aproximadamente de 490 Hz).
 Al variar la duración de estos pulsos,
estaremos variando proporcionalmente la
tensión promedio resultante; cuando la
duración del pulso coincidiera con el
período de la señal, la tensión promedio
de salida sería la máxima posible (5 V).
Las figuras ilustran lo anterior:
microcontrolador.
de E/S.

 Cada pin-hembra PWM tiene una resolución de 8 bits. Esto quiere decir
que se obtienen un máximo de 28 (256) valores diferentes posibles. Por
tanto, podemos tener 256 valores promedio diferentes para indicar la
duración deseada de los pulsos de la señal cuadrada.
 Si se establece el valor mínimo (0), estaremos emitiendo unos pulsos
extremadamente estrechos y generaremos una señal analógica equivalente
a 0V.
 Si se establece el valor máximo (255), estaremos emitiendo pulsos de

máxima duración y generaremos una señal analógica equivalente a 5 V.
 Cualquier valor entremedio emitirá pulsos de duración intermedia y por

microcontrolador.
de E/S.

 La diferencia de voltaje analógico existente entre dos valores promedio
contiguos se puede calcular mediante la división:
rango_voltaje_salida/número_valores_promedio. (5V–0V)/256 ≈19.5mV.
Nota: Saltos analógicos de 19.5mV. Valor promedio 123 equivale a 2.398V en

la salida PWM
 Los pines PWM viene controlados por tres temporizadores diferentes que
mantienen la frecuencia constante de los pulsos emitidos;
concretamente, los pines 3 y 11 son controlados por el “Timer1”, los
pines 5 y 6 por el “Timer2” y los pines 9 y 10 por el “Timer3”.
microcontrolador.
de E/S.
Las Salidas Analógicas (PWM)
Las funciones que sirven para gestionar salidas analógicas son las siguientes:
 analogWrite(): Envía un valor de tipo “byte” (especificado como segundo
parámetro) que representa una señal PWM, a un pin digital configurado como
OUTPUT (especificado como primer parámetro). En la placa Arduino UNO los
pines digitales que pueden generar señales PWM son los pines 3, 5, 6, 9, 10 y 11
(están marcados en la placa); cada vez que se ejecute esta función se
regenerará la señal. Esta función no tiene valor de retorno. Ejemplo:
pinMode(9,OUTPUT); analogWrite(9,valorPromedio);
Recordemos que una señal PWM es una señal digital cuadrada que
simula ser una señal analógica. El valor simulado de la señal analógica
dependerá de la duración que tenga el pulso digital (es decir, el valor
HIGH de la señal PWM).

Cualquier valor entre los dos extremos (0 y 255) implica un pulso de una
longitud intermedia, por ejemplo, el valor 128 generará una onda cuadrada, el
pulso es de la misma longitud que la del estado bajo, el valor analógico es de
2.5V.
Ejemplo 1:
Para conseguir cambiar la intensidad lumínica de un LED, primero deberemos
montar el circuito. La conexión del LED no tiene ningún misterio: su terminal
positivo ha de ir enchufado a un pin PWM de nuestra placa Arduino (por ejemplo el
nº 9) y su terminal negativo a tierra. Se recomienda también conectarle en serie un
divisor de tensión (de unos 220 ohmios está bien). A continuación, debemos escribir
el sketch, el cual modificará el voltaje PWM ofrecido por la salida analógica donde
esté conectado el LED (recordemos, de 0 –valor mínimo– a 255 –valor máximo–).
Programa “Brillo_LED”
microcontrolador.
de E/S.

Ejemplo:
Desarrollar un sistema térmico con un sensor PT100, que tiene una sensibilidad de
5mV/°C, el voltaje de salida del sensor es una señal analógica alimentada en el
canal AO, que debe procesarse mediante un algoritmo para representar la
temperatura medida, el programa debe visualizar los valores de la variable física.
El sensor debe energizarse mediante un divisor de voltaje, con una resistencia de
100Ω, el algoritmo debe eliminar la componente de DC (offset), este offset también
puede eliminarse mediante una señal de referencia (2.5V) insertada en el canal A0.
Dependiendo de la temperatura debe modificar la intensidad luminosa de un LED,
esto mediante una salida PWM.
“Temp_PT100”
microcontrolador.
de E/S.
Tarea #1.- Cuadernillo de ejercicios de la unidad 2
Elaborar un portafolio con las evidencias de simulación y puesta en marcha en

la placa de Arduino de los ejercicios desarrollados en clase, para comprobar
el funcionamiento de los puertos de entrada/salida del microcontrolador.
microcontrolador.
2.3 Estructura de los programas para microcontrolador
microcontrolador.
Figura A.6
microcontrolador.
Figura A.7
Acceder al IDE de Arduino

microcontrolador.
ESTRUCTURA GENERAL DE UN SKETCH (PROGRAMA)
Un programa diseñado para ejecutarse sobre un Arduino (un “sketch”)
siempre se compone de tres secciones:
 La sección de declaraciones de variables globales: ubicada directamente al
principio del sketch. Está reservada para escribir las diferentes declaraciones
de variables y/o funciones que necesitemos.
 La sección llamada “void setup()”: delimitada por llaves de apertura y cierre.
Se ejecutan una única vez, en el momento de encender (o resetear) la placa
Arduino.
 La sección llamada “void loop()”: delimitada por llaves de apertura y cierre.
Se ejecutan justo después de las de la sección “void setup()” infinitas veces
hasta que la placa se apague (o se resetee). Es decir, el contenido de “void
loop()” se ejecuta desde la 1ª instrucción hasta la última, para volver a
ejecutarse una y otra vez.
microcontrolador.
Por tanto, las instrucciones escritas en la sección “void setup()” normalmente sirven para
realizar ciertas preconfiguraciones iniciales y las instrucciones del interior de “void loop()”
son, de hecho, el programa en sí que está funcionando continuamente. En el siguiente
ejemplo se muestra la estructura de un programa en ambiente Arduino.
/* COMENTARIOS */
int mivariable=50; // Declaración e inicialización de una variable global
void setup() // Preconfiguraciones iniciales
{
Serial.begin(9600); // Instrucción que abre el canal serie para que pueda…
} // empezar la comunicación por él (Arduino-PC)
void loop() // Función principal, sustituye a la función main()

{
Serial.println(mivariable); // Envía a través del canal serie un dato (Arduino-PC)
mivariable=mivariable+1; // Instrucción de asignación
delay(1500); // Pausa el sketch durante los mseg especificados como parámetro
}
microcontrolador.
CREACIÓN DE INSTRUCCIONES (FUNCIONES) PROPIAS
Al crear nuestras propias funciones, escribimos código mucho más legible y fácil de
mantener. Segmentar el código en diferentes funciones permite al programador crear
piezas modulares de código que realizan una tarea definida. Las funciones hacen más
fácil la reutilización de código en otros programas (provocando que estos sean más
pequeños, modulares y legibles).
Para crear una función propia, debemos “declararlas”. Esto se hace en cualquier
lugar fuera de “void setup()” y “void loop()”, siguiendo la sintaxis marcada por la
plantilla siguiente:
tipoRetorno nombreFunción (tipo param1, tipo param2,...)

{
// Código interno de la función
}
microcontrolador.
CREACIÓN DE INSTRUCCIONES (FUNCIONES) PROPIAS…
Veamos un ejemplo de creación de una función que devuelve el resultado de multiplicar
dos números pasados como parámetros:
int multiplicar(int x, int y)

{
int resultado; /* “x” e “y” valdrán lo que se ponga en cada invocación */
resultado=x*y; // El tipo de la variable debe coincidir con el tipo de
retorno return resultado;
}
void loop()
void setup() {
{ int num1=2;
Serial.begin(9600); int num2=3;
} int producto;
producto=multiplicar(num1,num2);
Serial.println(producto);
}
microcontrolador.
COMUNICACIÓN SERIAL
Arduino posee como principal característica la habilidad de comunicarse con la
computadora a través del puerto serie, esto se conoce como comunicación serial.
Debido a que el uso de este puerto ha quedado un poco en desuso a favor de la
tecnología USB, Arduino cuenta con un convertidor de Serial a USB que permite a la
placa ser reconocida por la computadora como un dispositivo conectado a un puerto
COM aun cuando la conexión física sea mediante USB.
Arduino IDE proporciona una herramienta que permite enviar y visualizar los datos
que se manejan a través del puerto Serie. Dicha herramienta se conoce como
Monitor Serial y se puede encontrar en el menú de herramientas, en la opción
“Monitor Serial”. Es la forma más simple que existe para establecer la
comunicación serial con Arduino.
A través de esta ventana se puede enviar o recibir información utilizando el puerto

serie. Nótese que para poder abrir esta ventana es necesario que tengamos la placa
Arduino conectada a la PC mediante USB.
microcontrolador.
COMUNICACIÓN SERIAL…
Para iniciar la comunicación serial con Arduino utilizando el Monitor Serial
debemos establecer algunos comandos en el Arduino IDE y luego subirlos al
microcontrolador. Las funciones que permiten utilizar el monitor serial son:
 Serial.begin(rate): Abre el puerto serie y fija la velocidad en baudios para la
transmisión de datos en serie. El valor típico de velocidad para comunicarse
con el ordenador es 9600, aunque otras velocidades pueden ser soportadas.
Ejemplo:
void setup()
{
Serial.begin(9600); // abre el Puerto serie
} // configurando la velocidad en 9600 bps
Nota: Cuando se utiliza la comunicación serie los pines digitales 0 (RX) y 1 (TX) no
pueden utilizarse para otros propósitos.
microcontrolador.
 Serial.println(data): Imprime los datos en el puerto serie, seguido por un retorno de
carro (CR) y salto de línea (LF). Este comando toma la misma forma que
Serial.print(), pero es más fácil para la lectura de los datos en el Monitor Serie del
software.
Serial.println(analogValue); // envía el valor 'analogValue' al puerto
El siguiente ejemplo toma de una lectura analógica del pin 0 y envía estos datos al
ordenador cada segundo.
Ejemplo:
void loop()
{
void setup() int valor=analogRead(0);
{ Serial.println(valor); //envía valor
Serial.begin(9600); delay(1000); // espera 1 seg
} }

microcontrolador.
 Serial.read(): Devuelve el primer byte aún no leído de los que estén

almacenados en el buffer de entrada del chip TTL-UART. Al hacerlo, lo
elimina de ese buffer. Para devolver (leer) el siguiente byte, se ha de
volver a ejecutar Serial.read(). Y hacer así hasta que se hayan leído
todos. Cuando no haya más bytes disponibles, Serial.read() devolverá
-1. No tiene parámetros. Ejemplo: dato=Serial.read();
 Serial.parseInt(): Lee del buffer de entrada (eliminándolos de allí)

todos los datos hasta que se encuentre con un número entero. Su valor
de retorno –de tipo “long”– será entonces ese número entero
encontrado. Cuando detecte el primer carácter posterior no válido,
dejará de leer (y por tanto, no seguirá eliminando datos del buffer).
Esta instrucción no tiene parámetros. Ejemplo: valor=Serial.parseInt();
microcontrolador.
 Serial.available(): Devuelve el número de bytes (caracteres) disponibles para ser
leídos que provienen del exterior a través del canal serie (vía USB o vía pines
TX/RX). Estos bytes ya han llegado al microcontrolador y permanecen almacenados
temporalmente en una pequeña memoria de 64 bytes que tiene el chip TTL-UART
(llamada buffer) hasta que sean procesados mediante la instrucción Serial.read().
Si no hay bytes para leer, esta instrucción devolverá 0.
Ejemplo: numero=Serial.available();
Ejemplo:
int dato=0; //almacena el dato void loop()
{ // envía datos sólo si los recibe
void setup() if (Serial.available() > 0)
{ { // lee el byte de entrada
Serial.begin(9600); dato = Serial.read();
} Serial.print("He recibido: ");
Serial.println(dato, DEC);
}
}
microcontrolador.
 Serial.write(): Escribe los datos binarios al puerto serie. Estos datos se envían como
un byte o una serie de bytes; para enviar los caracteres que representan los dígitos de
un número use la función de print() en su lugar.
Sintaxis Parámetros
Serial.write(val) val: un valor a enviar como un solo byte
Serial.write(str) str: una cadena a enviar como una serie de bytes
Serial.write(buf, len) buf: una matriz a enviar como una serie de bytes
len: la longitud del buffer
ejemplo: Serial.write(45); // envia un byte con el valor 45

microcontrolador.
Ejemplo 3:
Se tienen 3 LED’s (rojo, verde y amarillo) conectados cada uno a través de
su divisor de tensión; se pretende manipular el brillo de un LED mediante
el envío de un comando adecuado a través del canal serie. La idea es
utilizar el “Serial monitor” para enviar a la placa Arduino un comando que
especifique qué LED queremos manipular (indicado por la letra “r”, “g” o
“y”) y qué cantidad de brillo le queremos asignar (indicado por un valor
entre 0 y 255).
Así, si queremos por ejemplo apagar el LED rojo el comando a enviar
debería ser “r0”. Y si queremos iluminar al máximo el LED amarillo, el
comando debería ser “y255”.
Programa “Brillo_3 LEDs”
microcontrolador.
microcontrolador.
microcontrolador.
Tarea #2: Librerías estándar de arduino
• EEPROM - reading and writing to "permanent" storage

• Ethernet / Ethernet 2 - for connecting to the internet using the Arduino Ethernet Shield,
Arduino Ethernet Shield 2 and Arduino Leonardo ETH
• Firmata - for communicating with applications on the computer using a standard serial
protocol.
• GSM - for connecting to a GSM/GRPS network with the GSM shield.
• LiquidCrystal - for controlling liquid crystal displays (LCDs)
• SD - for reading and writing SD cards
• Servo - for controlling servo motors
• SPI - for communicating with devices using the Serial Peripheral Interface (SPI) Bus
• Stepper - for controlling stepper motors
• TFT - for drawing text , images, and shapes on the Arduino TFT screen
• WiFi - for connecting to the internet using the Arduino WiFi shield
• Wire - Two Wire Interface (TWI/I2C) for sending and receiving data over a net of devices
or sensors.
• OneWire - control devices (from Dallas Semiconductor) that use the One Wire protocol.
2.4 Programación de puertos con interfaces para el manejo de
dispositivos periféricos sin manejo de potencia
Investigación-Exposición.
Dispositivos periféricos con arduino
 Displays de 7 segmentos.
 Displays LCD
 Teclados (lineal y matricial).
 Transistores.
 Relevadores.
 Optoacopladores.
 Puentes H discretos e integrados.
 Lámparas.
 Zumbadores, vibradores piezoeléctricos, bocinas, etc
 Motores de CD
 Motores a pasos.
 Servomotores.
microcontrolador.
dispositivos periféricos sin manejo de potencia.
2.4.1 Displays de 7 segmentos (Displays LED).
LED se define por sus siglas como diodo emisor de luz, no es más que
un pequeño chip de material semiconductor, que cuando es
atravesado por una corriente eléctrica, en sentido apropiado, emite
luz monocromática sin producir calor, es decir un componente
electrónico semiconductor, con polaridad por lo que se usará en
funciones de señalización, estética y, actualmente iluminación.
Los displays de 7 segmentos son dispositivos que se utilizan para

visualizar información. Cada segmento de un display está constituido
por un LED que, al activarse, es decir, cuando circula una corriente a
través suyo, se ilumina. El tipo de conexión de estos LED es lo que
determina si el display de 7 segmentos es de ánodo común o de
cátodo común.
microcontrolador.

microcontrolador.

 Decodificador BCD-7 segmentos
El decodificador BCD-7 segmentos tiene cuatro líneas de entrada en código BCD
y salidas capaces de excitar un display de siete segmentos para representar
cualquier dígito de 0 a 9.
De la misma forma que existen dos tipos de display de 7 segmentos, hay dos
tipos de decodificadores, uno cuyas salidas se activan con un 1, para displays de
7 segmentos de cátodo común, y otro que se activan con un cero para display
de 7 segmentos de ánodo común. Evidentemente, decodificador y display tienen
que ser del mismo tipo para poder ser conectados. A continuación se muestra
una imagen de lo que sería un decodificador BCD de 7 segmentos, 74LS47.
microcontrolador.

microcontrolador.

microcontrolador.

microcontrolador.

// Programa 7 segmentos void display (int a, int b, int c, if (mensaje=='0') if (mensaje=='5'){
int d, int e, int f, int g) { display (1,0,1,1,0,1,1);
int mensaje=0; // Función del display display (1,1,1,1,1,1,0); }
void setup() { } if (mensaje=='6'){
digitalWrite (2,a); if (mensaje=='1'){ display (1,0,1,1,1,1,1);
{ digitalWrite (3,b); display (0,1,1,0,0,0,0); }
digitalWrite (4,c); } if (mensaje=='7'){
Serial.begin(9600);
digitalWrite (5,d); if (mensaje=='2'){ display (1,1,1,0,0,0,0);
pinMode(2, OUTPUT); digitalWrite (6,e); display (1,1,0,1,1,0,1); }
digitalWrite (7,f); } if (mensaje=='8'){
pinMode(3, OUTPUT); digitalWrite (8,g); if (mensaje=='3'){ display (1,1,1,1,1,1,1);
pinMode(4, OUTPUT); } display (1,1,1,1,0,0,1); }
} if (mensaje=='9'){
pinMode(5, OUTPUT); void loop() if (mensaje=='4'){ display (1,1,1,0,0,1,1);
{ display (0,1,1,0,0,1,1); }
pinMode(6, OUTPUT);
if (Serial.available()>0) }
pinMode(7, OUTPUT); { }
mensaje=Serial.read(); delay(2000);
pinMode(8, OUTPUT);
}
}
microcontrolador.
2.4.2 Displays LCD

microcontrolador.
2.4.3 Teclados (lineal y matricial).

microcontrolador.
2.5 Programación de puertos con interfaces de potencia
2.5.1 Transistores.
microcontrolador.
2.5.2 Relevadores
microcontrolador.
2.5.3 Optoacopladores.
microcontrolador.
2.5.4 Puentes H discretos e integrados.

microcontrolador.
2.6 Desarrollo de aplicaciones para el manejo de (actuadores)
2.6.1 Lámparas
microcontrolador.
2.6.2 Zumbadores, vibradores piezoeléctricos, bocinas, entre otros.

microcontrolador.
2.6.3 Motores de CD
microcontrolador.
2.6.4 Motores a pasos.

microcontrolador.
2.6 Desarrollo de aplicaciones para el manejo de actuadores
2.6.5 Servomotores.
microcontrolador.
Practica #1, Unidad II
Desarrollar un sistema de control de temperatura y humedad relativa en

una incubadora de pollos; utilizar sensores analógicos, teclado matricial y
un display LCD para entrada y salida de datos de configuración.
Además, encender y apagar un elemento calefactor (foco incandescente)

y un ventilador de forma alternada, para mantener la temperatura en los
valores deseados. Utilizar un servomotor para mover los huevos 3 veces al
día.
Se puede incluir un aspersor para variar la humedad relativa.

microcontrolador.
Practica #2 unidad II
Mezcladora de líquidos.
Realizar un algoritmo en el IDE de Arduino e implementar el circuito eléctrico demostrativo en
físico, además, se debe simular en Proteus con los actuadores especificados para que desarrolle la
aplicación que se describe a continuación:
microcontrolador.
Mezcladora de líquidos.---
Tenemos dos bombas (PUMP 1 y PUMP 2) que se utilizan para transferir dos líquidos
separados a este tanque. Dentro del tanque hay un flotador unido a un sensor de nivel
(potenciómetro angular) para medir el volumen de la mezcla en el tanque.
También hay un mezclador eléctrico (MIXER) dentro del tanque que comienza a funcionar
durante un período de tiempo definido (6 segundos), mezclando los dos líquidos después
de que el tanque se haya llenado.
También contamos con una válvula de descarga (VALVE) en el fondo del tanque que
controla el drenaje del líquido del tanque.
Cuando el nivel del líquido cae al nivel de la posición baja (50% del tanque), el sensor en la
entrada del canal analógico en la placa de Arduino envía el voltaje correspondiente. Se
quiere escribir el programa para que cuando el nivel del líquido alcance este mínimo, las
bombas se activen y comiencen a llenar el tanque con los líquidos.
microcontrolador.
Mezcladora de líquidos.---
Las bombas continúan llenando el tanque hasta que el nivel alcanza su máximo (85% del
tanque) de nivel superior. Cuando esto suceda, el sensor enviará un voltaje indicándonos
que el tanque alcanzó su nivel máximo permitido.
Cuando se envía esta señal, primero se deben apagar las bombas para que no ingrese más
líquido al tanque, y luego se debe encender este mezclador. Queremos que el mezclador
funcione durante 6 segundos, mezclando los líquidos que se han bombeado al tanque.
Después de este tiempo, el mezclador debería apagarse automáticamente y la válvula de
descarga debería abrirse. Con la válvula abierta, el líquido se descargará del tanque y se
transferirá a otro lugar dentro de la fábrica para ser procesado.
Cuando el nivel del líquido en el tanque desciende al nivel mínimo establecido por el sensor,
la señal analógica de nivel bajo activará las bombas nuevamente, comenzando así un ciclo
repetitivo. El sistema tiene un paro de emergencia (STOP) para cuando sea requerido.
microcontrolador.
Evaluación de la unidad II
Sistema de riego automatizado para jardín

Desarrollar una aplicación en el IDE de Arduino que monitoree y controle las variables involucradas en
el proceso de riego de un jardín casero. Considere que se tiene una cisterna para suministro del agua
donde se introduce una bomba sumergible y en la parte superior se coloca un sensor para medir el nivel
de agua (sensor ultrasónico HC-SR04), útil para proteger el trabajo en vacío de la bomba.
El proceso de riego consiste en activar los aspersores cuando la humedad del suelo esté por debajo del
20% de humedad en el suelo lo cual se puede medir con el sensor YL-69. El riego solo puede hacerse
durante la tarde o la noche para evitar el daño de la flora causado por la evaporación, el nivel de luz
solar se puede detectar con un sensor de intensidad luminosa (LDR).
Es importante utilizar una pantalla LCD y otros dispositivos indicadores para emitir alertas en el proceso.

Microcontroladores MKT - Unidad II

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Microcontroladores MKT - Unidad II

Cargado por

Copyright:

Formatos disponibles

MICROCONTROLADORES

Culiacán, Sinaloa Septiembre 2020

COMPETENCIA ESPECIFICA A DESAROLLAR

Desarrolla aplicaciones para el manejo automático de diversos

 Un programa codificado en lenguaje C resulta muy útil en la

 Lo descriptivo de la sintaxis permite elaborar de mejor forma los

 Inicio y fin de bloque, permite agrupar un número de instrucciones

Booleanos & | ~ ˆ == && || |= &= != ? ! ˆ=

De Comparación > < >= <=

De Desplazamiento >> << <<= >>=

Manejo de apuntadores -> & * .

Paréntesis y Corchetes []{}()

Estos son los elementos más básicos para la generación de un programa,

 Asignaciones: Consiste en asignarle un valor a una determinada

char i, j; // Declaración de variables

 Formatos de asignación: La asignación puede ser hecha en decimal,

 Operaciones Lógicas: Se realizan con variables enteras y afectan

Permiten definir las funciones a ejecutar dependiendo de ciertas condiciones que

La condición verdadera puede ser también de la siguiente forma: Si se quiere

Puede usarse el if solo o el if-else. Si la condición es verdadera

Las funciones permiten agrupar código y optimizar el tamaño de éste. Se

 Las que solo ejecutan tareas y no devuelven valor.

 Las que ejecutan y devuelven un valor.

 Las que reciben parámetros y no devuelven.

 Las que reciben parámetros y devuelven información.

Funciones y Llamados a funciones…

 Cuando el valor se pasa a través de alguna variable, si el contenido de ésta es

 El paso de parámetros por referencia solo se puede realizar usando punteros, en

Son llamadas directamente a través del nombre o identificador correspondiente. La siguiente

char suma(); // Declaración

void suma(char i); // Declaración

char suma(char i,j); // Declaración

Arduino es una plataforma de prototipos electrónica de código abierto (open-

Arduino puede “sentir” el entorno mediante la recepción de entradas desde una

El modulo Arduino/Genuino Uno es una placa

 Tiene 14 pines de entrada/salida digitales

Todos estos pines-hembra digitales funcionan a 5 V, pueden proveer o

CONFIGURACIÓN DE LAS ENTRADAS Y SALIDAS DIGITALES

 pinMode(): Configura un pin digital (el número se especifica como primer

CONFIGURACIÓN DE LAS ENTRADAS Y SALIDAS DIGITALES…

 pulseIn(): Pausa la ejecución del sketch y espera a recibir en el pin de entrada

USO DE LAS ENTRADAS Y SALIDAS DIGITALES...

Ejemplos con salidas digitales:

1. La idea es encender y apagar un LED de forma periódica simplemente. El circuito

Ejemplos con salidas digitales:

2. Implementar un semáforo que encienda la siguiente secuencia: Luz roja (6

Ejemplos con salidas digitales:

3. Realizar un SKETCH que modifique el programa anterior seleccionando un pin de

Las Entradas Analógicas

 No obstante, la electrónica interna de la placa tan solo puede trabajar con

Las Entradas Analógicas…

Por ejemplo, en el caso del conversor en la placa Arduino, hay un máximo de

Todos los valores analógicos dentro de cada rango de 5mV (desde 0 a 5 V) se

 analogReference(): Es posible aumentar la resolución de lectura si se reduce el

Su sintaxis es la siguiente: analogReference(type), el parámetro son las opciones antes

Es decir, que si en algún momento necesitamos más pines-hembra digitales más

Las Entradas Analógicas…

Las Salidas Analógicas (PWM)…

 Si se establece el valor máximo (255), estaremos emitiendo pulsos de

 Cualquier valor entremedio emitirá pulsos de duración intermedia y por

Las Salidas Analógicas (PWM)…

Nota: Saltos analógicos de 19.5mV. Valor promedio 123 equivale a 2.398V en

Las Salidas Analógicas (PWM)…