UNIVERSIDAD TECNOLÓGICA DE PUEBLA

Organismo Público Descentralizado del Gobierno del Estado de Puebla

DIVISIÓN
MECATRÓNICA - AUTOMATIZACIÓN

ASIGNATURA
MICROCONTROLADORES

PORTAFOLIO DE EVIDENCIAS

PROFESOR
MARTINNEZ TLALPA GONZALO

ALUMNA
CAMACHO ÁLVAREZ SANDRA

GRUPO
5°F

1
Índice
Introducción...............................................................................................................3
Lenguajes de programación ..................................................................................3
Ventajas de lenguajes de programación de alto nivel ...........................................4
Lenguaje C ............................................................................................................5
Practica 5 Motor A Pasos ..........................................................................................6
Marco Teórico........................................................................................................6
Motores unipolares ................................................................................................7
Motores bipolares ..................................................................................................7
Practicas ................................................................................................................9
Practica 6 pantalla de cristal líquido (LCD) .............................................................11
Marco Teórico......................................................................................................12
¿Como es su conexionado? ................................................................................12
Practica ...................................................................................................................14
Practica 7 Analog-to-digital converter (ADC) ..........................................................18
Marco Teórico......................................................................................................18
Practicas .................................................................................................................21
Practica 8 Teclado Matricial 4X4 .............................................................................26
Practicas .................................................................................................................28
Practica 9 Timer 0 ...................................................................................................32
Marco Teórico......................................................................................................32
Practicas .................................................................................................................34
Practica 10 Comunicación Serial ............................................................................41
Marco Teórico......................................................................................................41
LabVIEW .............................................................................................................43
Practicas .................................................................................................................44
Practica 11 pulse-width modulation (PWM).............................................................47
En los motores ...................................................................................................47
Practicas .................................................................................................................49
2
Conclusión ..............................................................................................................50

Referencias Bibliograficas ..................................................................................... 56

Introducción

Un microcontrolador es un circuito integrado que incluye en su interior las tres

unidades funcionales de una computadora: unidad central de procesamiento,
memoria y periféricos de entrada y salida. La memoria del programa en forma de
flash ROM a menudo se incluyen en el chip, así como una pequeña cantidad de
RAM . Estos son diseñados para aplicaciones embebidas, en contraste con los
microprocesadores utilizados en computadoras personales u otras aplicaciones de
propósito general.

Los microcontroladores son utilizados en los productos controlados

automáticamente y dispositivos, tales como los sistemas de control del motor del
automóvil, los dispositivos médicos implantables, mandos a distancia, máquinas de
oficina, electrodomésticos, herramientas eléctricas, juguetes, etc. Al reducir el
tamaño y el costo en comparación con un diseño que utiliza un microprocesador
independiente, memoria y dispositivos de entrada/salida. Algunos
microcontroladores pueden utilizar bits de palabras de cuatro y funcionan a la
velocidad de la frecuencia de un reloj incorporado tan bajas como 4 [kHz], de bajo
consumo de energía. Por lo general, tendrá la capacidad de conservar la
funcionalidad a la espera de un evento como pulsar un botón u otra interrupción.
Otros microcontroladores pueden servir en roles críticos de rendimiento, donde
pueden necesitar que actué más como un procesador de señal digital (DSP), con
velocidades de reloj más alta y el consumo de energía.

Lenguajes de programación

El microcontrolador ejecuta el programa cargado en la memoria Flash. Esto se

denomina el código ejecutable y está compuesto por una serie de ceros y unos,

3
aparentemente sin significado. Dependiendo de la arquitectura del
microcontrolador, el código binario está compuesto por palabras de 12, 14 o 16 bits
de anchura. Cada palabra se interpreta por la CPU como una instrucción a ser
ejecutada durante el funcionamiento del microcontrolador. Todas las instrucciones
que el microcontrolador puede reconocer y ejecutar se les denominan
colectivamente Conjunto de instrucciones. Como es más fácil trabajar con el sistema
de numeración hexadecimal, el código ejecutable se representa con frecuencia
como una serie de los números hexadecimales denominada código Hex. En los
microcontroladores PIC con las palabras de programa de 14 bits de anchura, el
conjunto de instrucciones tiene 35 instrucciones diferentes.

Ventajas de lenguajes de programación de alto nivel

A pesar de todos los lados buenos, el lenguaje ensamblador tiene algunas

desventajas:
• Incluso una sola operación en el programa escrito en ensamblador consiste
en muchas instrucciones, haciéndolo muy largo y difícil de manejar.
• Cada tipo de microcontrolador tiene su propio conjunto de instrucciones que
un programador tiene que conocer para escribir un programa
4
 • Un programador tiene que conocer el hardware del microcontrolador para
escribir un programa

Programa escrito en C (El mismo programa compilado al código ensamblador):

Lenguaje C

El lenguaje C dispone de todas las ventajas de un lenguaje de algunas operaciones

tanto sobre los bytes como sobre los bits (operaciones lógicas, desplazamiento etc.).
Las características de C pueden programación de alto nivel (anteriormente
descritas) y le permite realizar ser muy útiles al programar los microcontroladores.
Además, C está estandarizado (el estándar ANSI), es muy portable, así que el
mismo código se puede utilizar muchas veces en diferentes proyectos. Lo que lo
hace accesible para cualquiera que conozca este lenguaje sin reparar en el

5
propósito de uso del microcontrolador. C es un lenguaje compilado, lo que significa
que los archivos fuentes que contienen el código C se traducen a lenguaje máquina
por el compilador. Todas estas características hicieron al C uno de los lenguajes de
programación más populares.

La figura anterior es un ejemplo general de lo que sucede durante la compilación

de programa de un lenguaje de programación de alto nivel a bajo nivel.

Practica 5 Motor A Pasos

Marco Teórico

El motor paso a paso conocido también como motor de pasos es un dispositivo

electromecánico que convierte una serie de impulsos eléctricos en desplazamientos
angulares discretos, lo que significa que es capaz de girar una cantidad de grados
(paso o medio paso) dependiendo de sus entradas de control. El motor paso a paso
se comporta de la misma manera que un conversor digital-analógico (D/A) y puede
ser gobernado por impulsos procedentes de sistemas digitales. Este motor presenta
las ventajas de tener precisión y repetitividad en cuanto al posicionamiento. Entre
sus principales aplicaciones destacan los robots, drones, radiocontrol, impresoras
digitales, automatización, fotocomponedoras, preprensa, etc.

6
Motores unipolares

Estos motores cuentan con dos bobinas con un punto medio de los cuales salen los
cables hacia el exterior; estos cables se conectan a la fuente mientras que los
extremos de las bobinas son aterrizadas para cerrar el circuito; dependiendo del tipo
de motor, las líneas comunes pueden ser independientes o no. Esta configuración
puede ser vista de las siguientes formas: que el motor tiene dos bobinas pequeñas
conectadas a un punto en común, o que una bobina está divida en dos por medio
de un punto común. Ahora, y dependiendo de qué media bobina se energice, se
puede tener un polo norte o un polo sur; si se energiza la otra mitad, se obtiene un
polo opuesto al otro. En la Ilustración 0 se muestra un esquema representativo del
motor a pasos unipolar.

Un motor unipolar de 5 cables es así porque los cables intermedios están unidos en
un sólo nodo -ver la Ilustración 1- mientras que el motor unipolar de 6 cables tiene
un cable de alimentación para cada par de bobinas -ver Ilustración 2-

Motores bipolares

Cuentan con dos bobinas sin ningún punto medio donde salga un cable, por lo que
se tienen cuatro cables y cada par corresponde a las terminales de una bobina

7
Ilustraciones 3 y 4- Dada la configuración de la bobina, la corriente puede fluir en
dos direcciones, necesitando un control bidireccional o bipolar. En general, con
respecto al sentido de giro de los motores a pasos bipolares, vale la pena recordar
que el sentido de giro depende de la dirección del flujo de la corriente por las bobinas
ya que ésta induce en el embobinado un campo magnético que genera un polo
magnético norte y sur, de ahí que el rotor se mueva para que uno de los polos del
rotor sea opuesto al de la bobina -localizado en el estator-, como se muestra en la
Ilustración 3.

Explicado lo anterior, y resumiendo en palabras más simples, el motor bipolar se

denomina así porque al momento de energizar las bobinas del estator se generan
simultáneamente dos polos magnéticos, uno norte y uno sur, y el motor unipolar es
denominado así porque al tener un cable que es común para dos bobinas, se puede
energizar una sola bobina y con esto crear un polo magnético para atraer a un polo
del rotor; al no tomar en cuenta ese cable común el motor unipolar puede ser usado
como un bipolar.
8
Practicas

1. Giro a la izquierda, giro a la derecha y paro de un motor a pasos

#include <16f877a.h>
#fuses xt, nowdt
#use delay (crystal=4Mhz)

#use fast_io(c)
#use fast_io(d)

void main(){ set_tris_c(0xFF);

set_tris_d(0x00);

while(true){

if(input(pin_c0)==1){

while(1){
if(input(pin_c4)==1) break;
output_high(pin_d0);
delay_ms(10);
output_low(pin_d0);
delay_ms(10);

9
 output_high(pin_d1);
delay_ms(10); output_low(pin_d1);
delay_ms(10);

output_high(pin_d2);
delay_ms(10); output_low(pin_d2);
delay_ms(10);

output_high(pin_d3);
delay_ms(10); output_low(pin_d3);
delay_ms(10);
}

else{
output_low(pin_d0);
output_low(pin_d1);
output_low(pin_d2);
output_low(pin_d3);

if(input(pin_c1)==1){

while(1){
if(input(pin_c4)==1) break;
output_high(pin_d3);

10
delay_ms(10);
output_low(pin_d3);
delay_ms(10);

output_high(pin_d2);
delay_ms(10); output_low(pin_d2);
delay_ms(10);

output_high(pin_d1);
delay_ms(10); output_low(pin_d1);
delay_ms(10);

output_high(pin_d0);
delay_ms(10); output_low(pin_d0);
delay_ms(10);
}

else{
output_low(pin_d0);
output_low(pin_d1);
output_low(pin_d2);
output_low(pin_d3);

Practica 6 pantalla de cristal líquido (LCD)

11
Marco Teórico

El LCD(Liquid Crystal Dysplay) o pantalla de cristal líquido es un dispositivo

empleado para la visualización de contenidos o información de una forma gráfica,
mediante caracteres, símbolos o pequeños dibujos dependiendo del modelo. Está
gobernado por un microcontrolador el cual dirige todo su funcionamiento. En este
caso vamos a emplear un LCD de 16x2, esto quiere decir que dispone de 2 filas de
16 caracteres cada una. Los píxeles de cada símbolo o carácter, varían en función
de cada modelo.

¿Como es su conexionado?

En la siguiente imagen de Proteus se puede observar la estructura de sus pines. Lo

podemos dividir en los Pines de alimentación, pines de control y los pines del bus
de datos bidireccional. Por lo general podemos encontrar ademas en su estructura
los pines de Anodo de led backlight y cátodo de led backlight.

Pines de alimentación:

Vss: Gnd
Vdd: +5 voltios
Vee: corresponde al pin de contraste, lo regularemos con un potenciómetro de 10K
conectado a Vdd.

Pines de control:

12
RS: Corresponde al pin de selección de registro de control de datos (0) o registro
de datos(1). Es decir el pin RS funciona paralelamente a los pines del bus de
datos. Cuando RS es 0 el dato presente en el bus pertenece a un registro de
control/instrucción. y cuando RS es 1 el dato presente en el bus de datos
pertenece a un registro de datos o un carácter.
RW: Corresponde al pin de Escritura(0) o de Lectura(1). Nos permite escribir un
dato en la pantalla o leer un dato desde la pantalla.
E: Corresponde al pin Enable o de habilitación. Si E(0) esto quiere decir que el
LCD no esta activado para recibir datos, pero si E(1) se encuentra activo y
podemos escribir o leer desde el LCD.

Pines de Bus de datos:

El Bus de datos bidireccional comprende desde los pines D0 a D7. Para realizar la
comunicación con el LCD podemos hacerlo utilizando los 8 bits del bus de datos(D0
a D7) o empleando los 4 bits mas significativos del bus de datos(D4 a D7). En este
caso vamos a explicar la comunicación con el bus de 4 bits.

¿DDRAM y CGROM?

Son las dos zonas de memoria del LCD.

La memoria DDRAM(Data Display Ram): corresponde a una zona de memoria
donde se almacenan los caracteres que se van a representar en pantalla. Es decir
es la memoria donde se almacenan los caracteres a mostrar con su correspondiente
posición.

La memoria CGROM es una memoria interna donde se almacena una tabla con los
caracteres que podemos visualizar en el lcd. En la imagen podemos ver un ejemplo
de la tabla con un contenido de 192 caracteres.

La memoria CGRAM(Character Generator Ram): en ella se pueden almacenar

nuestros propios caracteres.

La librería del LCD:

Para poder visualizar los caracteres o símbolos en el LCD es necesario que en el

programa de código fuente a emplear, incluyamos la librería de este.
En este caso empleamos la librería "lcd.c", la cual hemos modificado. Siempre que
utilicemos una librería de este tipo tendremos que analizarla para saber cuales son
los pines de control y los pines para el Bus de datos, en este caso podemos
observar que están definidos al comienzo de la misma.

13
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7

En el resto de la librería se puede encontrar todas las estructuras necesarias así

como las funciones que nos permiten utilizar nuestro LCD.
Podemos encontrar funciones como :

lcd_init: inicializa el lcd.

lcd_gotoxy: establece la posicion de escritura en el lcd.

lcd_putc: nos muestra un dato en la siguiente posición del lcd, podemos emplear
funciones como \f para limpiar el display, \n cambio a la segunda línea, \b mueve
una posición atrás.

lcd_getc(x,y): devuelve caracteres a la posición x,y.

Otras funciones: lcd_send_nibble(BYTE n), lcd_send_byte(BYTE address, BYTE
n).

Practica

1. Contador

#include <18f4550.h>
#fuses xt, nowdt
#use delay(crystal=4Mhz)

#use fast_io(d)
#include <lcd.c>//Libreria para el manejo del LCD float
A=0;

14
void main(void)
{ lcd_init(); //Inicia LCD
lcd_gotoxy(2,1); //Columna 3 fila 1
lcd_putc(" DIEGO VICTOR"); //Escribe "DIEGO ORTIZ"
lcd_gotoxy(5,2); //Columna 5 fila 1 lcd_putc("
Contador"); //Escribe "Contador" delay_ms(2000);
// Retardo lcd_putc("\f"); // Limpia pantalla
lcd_putc("Conteo:\n"); // Salta de Linea y Escribe"Conteo:"

while(true)
{

if(input(pin_A0)==0) // Pregunta si RA0 es cero

{
A =A + 0.5; // Incremento el conteo
delay_ms(500); // Para visualizar correctamente el conteo retardo

if(A>=100) // Preguto si A es mayor o igual a 20,

{ // cuando sea igual iguala "A" a cero
A=0;
}
}
lcd_gotoxy(2,2); //Columna 2 fila 2 lcd_putc(" ");
// Limpia ese sector de pantalla
printf(lcd_putc,"%2.1F",A); // Imprime el conteo por la lcd
}
}

15
 2. Recorrimiento de palabras

#include <16f877a.h>
#fuses xt, nowdt
#use delay(crystal=4Mhz)
#include <lcd.c>
#use fast_io(d)
int i;

void main(){
set_tris_d(0x00); lcd_init();

while(true){ lcd_gotoxy(5,1);
printf(lcd_putc,"CURSO UTP");
lcd_gotoxy(4,2);
printf(lcd_putc,"MECATRONICA");
delay_ms(5000);

16
 for(i=0;i<=16;i++){ lcd_gotoxy(4,1);
lcd_putc("PRACTICA 6"); lcd_gotoxy(i,2);
printf(lcd_putc,"DIEGO MICHAEL ORTIZ");
delay_ms(500); lcd_putc("\f");
}

for(i=16;i>=1;i--){
lcd_gotoxy(4,1);
printf(lcd_putc,"PRACTICA 6");
lcd_gotoxy(i,2);
printf(lcd_putc,"VICTOR POPOCA");
delay_ms(500); lcd_putc("\f");
}
}

17
Practica 7 Analog-to-digital converter (ADC)

Marco Teórico

El CAD conversor analógico digital PIC (no todos los PIC lo tienen, para los ejemplos
se utilizará el PIC16F877A), permite medir señales analógicas en forma digital, para
ello el PIC cuenta con pines por donde le llegará la señal analógica, estos pines
deben configurarse como entradas analógicas, el conversor analógico digital PIC
cuenta con un circuito que carga un condensador interno al PIC con la tensión
analógica que le está llegando a la entrada analógica, luego la tensión almacenada
en el condensador lo convierte en un número binario de 10 bits que representará la
tensión almacenada en el condensador, este número binario se guarda en sus
registros ADRESH y ADRESL de 8 bits cada uno pero estos actúan como un solo
registro de 16 bits, en el registro ADRESH se guardan los bits mas significativos y
en el registro ADRESL se guardan los bits menos significativos, el número que
representa la tensión almacenada en el condensador y guardado en forma binaria
dentro de estos registros será de 10 bits para el PIC16F877A, la cantidad de bits de
este número depende del conversor analógico digital PIC del microcontrolador PIC
utilizado.
Los registros de control del ADC en un PIC (familia 18F 2520/4520)

Para estos ejemplos voy a usar código para la familia PIC18F2520/4520 con algunos
comentarios sobre la familia 252/452. El conversor AD es una de los módulos de un
PIC donde hay más diferencias entre modelos: distintos número de canales AD,
diferentes formas de programar que canales son digitales o analógicos, la
posibilidad o no de programar tiempos de adquisición, etc.

Esto hace que la configuración del ADC sea bastante dependiente del modelo y
siempre sea bueno tener a mano la documentación ante comportamientos
inesperados. Por ejemplo, los registros asociados al puerto serie son los mismos
entre una amplia gama de dispositivos. Por el contrario, es fácil que el número de
registros de configuración cambie entre modelos.

La familia PIC18F2520 tiene 3 registros de control asociados al ADC (ADCON0,

ADCON1 y ADCON2). Por el contrario, la familia 252/452, al tener menos
funcionalidades, sólo necesita 2 (ADCON0 y ADCON1). De todas formas, los
nombres y funciones de los bits comunes serán los mismos que los aquí descritos,
aunque pueden estar situados en diferentes registros.

Además de los registros de control tenemos otros dos registros ADRESH y ADRESL
(AD result High/Low) donde se guarda el resultado de la conversión, pero estos si
son comunes entre dispositivos.

18
Veamos un resumen de estos registros (de nuevo, los datasheet de Microchip son
los mejores manuales de usuario):

Registro ADCON0: permite seleccionar (CHS) el canal del que tomaremos la

medida. También tiene el bit que habilita el conversor (ADON) y que arranca (GO)
el proceso de conversión.

Bit # Bit 7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 bit 0

Nombre X X CHS3 CHS2 CHS1 CHS0 GO ADON
Función No No Selección de canal: Lanza ON/OFF
usado usado desde 0 (0000) a 12 (1100) ADC

ADON: Encendido (1) o apagado (0) del modulo ADC.

GO : Se pone a 1 para iniciar el proceso de conversión. Cuando la conversión ha

terminado el módulo lo pone a 0. Así es como sabemos que podemos recoger el
resultado (en ADRESH/ADRESL)

CHS: selecciona cual de los posibles 13 canales analógicos se conecta al ADC para
medir.

Registro ADCON1: dedicado a seleccionar cuales de los posibles canales se van

a usar como entradas analógicas y a programar el uso o no de voltajes de referencia
externos (distintos de los valores 0 y 5V por defecto)

Bit # bit 7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 bit 0

Nombr X x VCFG VCFG PCFG PCFG PCFG PCFG
e 1 0 3 2 0 0
Funció No No Uso (1) de Reparto canales
n usad usad Vref (+),Vref(-) digitales / analógicos
o o

VCFG1: por defecto (0) usamos Vss=Gnd=0V como Vref-. Si es 1 se tomara como
Vref- el voltaje presente en AN2.

VCFG0: Lo mismo que el anterior pero para Vref+. Por defecto usaremos Vdd
(alimentación, típicamente 5 o 3.3V) como Vref+. Si es 1 se usa el voltaje presente
en AN3 como Vref+.

PCFG: Posiblemente no necesitaremos todos los posibles canales analógicos.

Estos bits permiten decidir cuales de los pines se dedican a canales analógicos y

19
cuales permanecen como canales digitales. Los valores posibles van desde 0000
(todos analógicos) a 1111 (todos digitales).

Los canales analógicos se denotan en la documentación como AN0, AN1, AN2, etc.
Los dispositivos con 8 canales (252/452) los reparten entre el puerto A y el E. Los
que tienen 13 canales usan también parte del puerto B (2520/4520). Mirar la
documentación, porque el orden no es consecutivo. Por ejemplo, para el 4520

Can AN AN AN AN AN AN AN AN AN AN AN AN AN
al 0 1 2 3 4 5 6 7 8 9 10 11 12
Pin RA RA RA RA RA RE RE RE RB RB RB RB RB
0 1 2 3 5 0 1 2 2 3 1 4 0

Registro ADCON2: información para determinar los tiempos Ta y Tc del conversor

y la forma en la que el resultado (10 bits) se guarda en ADRESH:ADRESL (16 bits).

Bit # bit 7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 bit 0

Nombr ADFM x ACQT ACQT ACQT ADCS ADCS ADCS
e 2 2 2 2 1 0
Funció Format No Programación T Reloj del ADC
n o usad adquisición
o

ADFM: Formateo del resultado. El conversor da 10 bits que se guardan en dos

registros (ADRESH:ADRESL) de 8 bits, por lo que 6 de los 16 bits estarán vacíos.
Si ADFM=1 el resultado está desplazado a la derecha, por lo que los 6 bits más
significativos de ADRESH estarán vacíos. Si es 0 se justifica a la izquierda y son los
6 bits menos significativos de ADRESL los que están vacíos. El caso ADFM=1 se
suele usar cuando nos interesan los 10 bits. El resultado se puede pasar a un entero
de 16 bits como:
res = (ADRESH<<8)+ADRESL;

El caso ADFM=0 se suele usar si sólo queremos los 8 bits más significativos. En
ese caso basta hacer: res = ADRESH;

ACQT: bits para la programación del T de adquisición. Recordar que el tiempo de

adquisición es el que debemos esperar después de seleccionar (conectar) un canal
al ADC mientras se carga el condensador cuyo voltaje posteriormente mediremos.
Si escogemos 000 el usuario es responsable de la espera (de unos pocos usec,
especificada en la documentación) entre la selección del canal (poner los bits CHS
adecuados en ADCON0) y el inicio del proceso de conversión (poner a 1 el bit GO
de ADCON0).

20
El modo manual (000) era la norma entre familias anteriores, que de hecho no
contaban con estos bits de configuración. En la familia 2520/4520 es posible
programar dicho tiempo de espera. De esta forma tras seleccionar el canal podemos
inmediatamente lanzar la conversión (ADCON0.GO=1) y el módulo esperara el
tiempo programado antes de iniciar la conversión. Esto permite optimizar el
aprovechamiento del ADC como veremos.

El tiempo de adquisición es la suma de varios factores, siendo los principales la

capacidad del condensador a cargar y el tiempo que tarda el amplificador del ADC
en estabilizarse. Es importante consultar el datasheet si queremos optimizar el
muestreo porque podemos encontrarnos bastantes diferencias entre diversos
modelos.

ADCS: seleccionan la velocidad del reloj del ADC como una fracción (div = 2, 4, 8,
16, 32, 64) del reloj principal (aunque también es posible asociarlo a un oscilador
RC independiente). El inverso de la frecuencia del ADC determina el llamado Tad,
que viene a ser el tiempo dedicado a obtener cada bit del resultado:

F_ad = Fosc / div

Tad = 1/F_ad = div / Fosc (en microsec si Fosc está en MHz)

Obviamente deberíamos escoger un divisor bajo para obtener la frecuencia más alta
(Tad más pequeño) posible para tardar lo menos posible en cada conversión. Sin
embargo hay una limitación: el Tad no puede ser menor que un cierto tiempo mínimo
dependiente del modelo. Por ejemplo para la familia 252/452 se recomienda que
Tad sea como mínimo 1.6 usec. En cambio para la 2520/4520 podemos bajar a 0.75
usec.

Eso significa que si tenemos un cristal de 20 Mhz, el divisor escogido sería:

1:32 si tenemos un 452, ya que Tad = div / Fosc = 32/20 Mhz = 1.6 usec =
recomendado

1:16 si tenemos un 4520 ya que Tad = div / Fosc = 16/20 MHz = 0.8 usec > 0.75
usec recomendados

Practicas

21
 1. ADC con LM35 #include
<18f4550.h>
#device adc = 10
#fuses xt, nowdt
#use delay(crystal= 4Mhz)
#include <lcd.c>

long d; float
h; void
main(){

set_tris_d(0x00); setup_adc_ports(an0);
setup_adc(adc_clock_internal);
lcd_init();

while(true){

set_adc_channel(0); delay_ms(1);
d = read_adc(); h = d* 0.4882;
lcd_gotoxy(1,1); printf(lcd_putc,"ADC
=%4Ld" ,d); lcd_gotoxy(1,2);
printf(lcd_putc,"Temperatura=%1.2f",h);

2. Calculadora con dos potenciómetros

#include <16f877a.h>
#device adc=10
#fuses xt,nowdt
#use delay(crystal=4Mhz)
#include <lcd.c>

22
int16 x,y,num,h,j,adc,adc2,res; float
res3,a,b;

void main(){

lcd_init(); set_tris_d(0x00);
set_tris_b(0xFF);
SETUP_ADC(ADC_CLOCK_INTERNAL);
SETUP_ADC_PORTS(all_analog);

while(true){

set_adc_channel(0); //Canal 0 del adc

delay_us(20);
adc = read_adc(); // Lee el adc y lo almacena en la variable d
x = (5 * adc)/51; //Valor leido por le voltaje de entrada sobre 51 se almacena
en h

set_adc_channel(1); //Canal 1 del adc

delay_us(20);

adc2 = read_adc(); //Lee el adc y lo almacena en d

y = (5 * adc2)/51; // (5 volts * 1024)/51 se almacena en j

h=input(pin_b0);
j=input(pin_b1);
delay_ms(20);

23
num=(h*1)+(j*2); switch
(num)
{
case 0: /*SUMA*/
lcd_gotoxy(1,1); lcd_putc("\f");
printf(lcd_putc,"Suma"); res = x + y;
lcd_gotoxy(1,2); printf(lcd_putc,"%ld
+%ld =%ld",x,y,res); delay_ms(3000);
break;

case 1:
/*RESTA*/

lcd_gotoxy(1,1);
lcd_putc("\f");
printf(lcd_putc,"Resta");
res = x - y; lcd_gotoxy(1,2);
printf(lcd_putc,"%ld -%ld
=%ld",x,y,res);
delay_ms(3000); break;

case 2:
/*MULTIPLICACION*/

lcd_gotoxy(1,1); lcd_putc("\f");
printf(lcd_putc,"Multiplicacion"); res = x
* y; lcd_gotoxy(1,2);

24
printf(lcd_putc,"%ld x%ld =%ld",x,y,res);
delay_ms(3000); break;

case 3:
/*DIVISION*/
SET_ADC_CHANNEL(0);
delay_us(20);
adc= read_adc();
a=(5 * adc)/51;

SET_ADC_CHANNEL(1);
delay_us(20);
adc2= read_adc();
b=(5 * adc2)/51;
lcd_gotoxy(1,1);
lcd_putc("\f");
lcd_putc("DIVISION: ");
res3=a/b; if((a>0 &&
b==0)||(a==0 && b==0)){
lcd_putc("\f");
lcd_gotoxy(1,1);
lcd_putc("DIVISION: ");
lcd_gotoxy(1,2);
printf(lcd_putc,"%.1f/%.1f=
Error",a,b);
delay_ms(3000);

25
 } else{ lcd_gotoxy(1,2);
printf(lcd_putc,"%.1f/%.1f=%.1f",a,b,res3);
delay_ms(1000);}

break;

default:
output_d(0x00);
delay_ms(100); break;
}

}
}

Practica 8 Teclado Matricial 4X4

Un teclado matricial es un simple arreglo de botones conectados en filas y colúmnas,

de modo que se pueden leer varios botones con el mínimo número de pines
requeridos. Un teclado matricial 4x4 solamente ocupa 4 lineas de un puerto para las
filas y otras 4 lineas para las colúmnas, de este modo se pueden leer 16 teclas
utilizando solamente 8 líneas de un microcontrolador. Si asumimos que todas las
columnas y filas inicialmente están en alto (1 lógico), la pulsación de un botón se
puede detectar al poner cada fila a en bajo (0 lógico) y checar cada columna en
busca de un cero, si ninguna columna está en bajo entonces el 0 de las filas se
recorre hacia la siguiente y así secuencialmente.

Un modo simple de detectar la tecla presionada es incrementar una variable con la

cuenta de las teclas revisadas, de este modo al detectaruna pulsación el valor de la
cuenta será el valor de la tecla presionada. Si al final no se presionó ninguna tecla
la variable se pone a cero y la cuenta vuelve a comenzar. El puerto B del
microcontrolador 16f628 (así como en el 16f877) viene preparado especialmente
para el control de un teclado matricial 4x4. Para tener siempre un valor de 1 lógico
en las colúmnas del teclado (parte alta del puerto B del pic) es necesario conectar
resistencias de pull-up, sin embargo el puerto B cuenta con resistencias de pull-up
integradas, de ese modo es posible trabajar con un teclado matricial sin necesidad
de ningún componente externo.

26
Las resistencias de pull-up del puerto B se habilitan poniendo en 0 el bit NOT_RBPU
del registro OPTION_REG.Al método aqui expuesto para detectar la pulsación de
una tecla en un teclado matricial se le conoce como muestreo secuencial. Existen
otros, sin embargo esté es tal vez el más sencillo. En el siguiente ejemplo cada tecla
del teclado matricial tiene un valor de 0 a F, valor que se despliega en un display de
7 segmentos. El el código necesario para leer un teclado matricial con un
microcontrolador pic 16f628 es el siguiente.

Existen otros métodos de manejar teclados matriciales, pero creo que ésta es la
más sencilla. Para terminar una imágen del circuito:

27
Practicas

1. Cerradura Electrónica
#include <16f877a.h>
#fuses xt, nowdt
#use delay(crystal= 4Mhz)
#define lcd_data_port getenv("sfr:portd")//Se declara que del pin d4 al d7 sera para
los datos
#define lcd_enable_pin pin_d0
#define lcd_rs_pin pin_d1
#define lcd_rw_pin pin_d2
#define use_portb_kbd true //Se utilizara el puerto b para el teclado matricial
#include <lcd.c>
#include <kbd4x4.c> //Libreria para amnejar Teclado 4x4
#rom 0x2100 = {'1','3','0','3'} //Escribir en la memoria eeprom
void main(){ set_tris_c(0x00); int i; //Es un contador int j=0;
char d; //Lectura del kbd
char dato[4], clave[4]; //Dato almacena los digitos, clave es la contraseña
port_b_pullups (true); lcd_init(); kbd_init();
for(;;){
lcd_putc("\f BIENVENIDO");
lcd_putc("\n USUARIO");
delay_ms(1500);
lcd_putc("\fINGRESE LA
CLAVE");
output_low(pin_d3);
output_low(pin_c1);

i=0;

28
 while(i<4){ d
= kbd_getc(); if
(d!=0){

dato[i] = d;
i++;
lcd_gotoxy(i,2);
lcd_putc('*');
}

for(i=0;i<4;i++){ clave[i] = read_eeprom(i); //Guarda la clave en

el vector Clave[3]
}
if( dato[0] == clave[0] && dato[1] == clave[1] && dato[2] == clave[2] &&
dato[3]==clave[3]){

lcd_putc("\f CLAVE CORRECTA");

lcd_putc("\n ADELANTE");
output_high(pin_d3); output_low(pin_c1);
delay_ms(2000);

j=0;
}

else{

29
 lcd_putc("\fCLAVE INCORRECTA");
lcd_putc("\nACCESO DENEGADO");
j++; if(j==1){ lcd_putc("\f
Intento 1"); lcd_putc("\n accso
invalido");
} if(j==2){ lcd_putc("\f
Intento 2"); lcd_putc("\n
WARNING!");
delay_ms(300);
}
if(j==3){
lcd_putc("\f BLOQUEADO");
delay_ms(60000);
j=0;
}
output_high(pin_c1);
output_low(pin_d3); delay_ms(2000);
}

30
31
Practica 9 Timer 0

Marco Teórico

El Timer0 es un temporizador/contador ascendente de 8 bits, cuando trabaja con el

reloj del PIC se le suele llama temporizador y cundo los pulsos los recibe de una
fuente externa a través de la patilla RA4/TOCKI se le llama contador, pero digamos
que es el mismo perro con dos collares diferentes. Para no liarnos con las patillas y
el nombre de los registros voy a mostrar los registros y patillas implicadas solo en
el TMR0 utilizando el PIC16f84, aunque podría ser otro cualquiera ya que este
temporizador viene incorporado en todos los PIC.
OPTION: los bits que están en color verde son los que están implicados en la
configuración del TIMER0

• PS0, PS1 y PS2: Configuración del preescaler. El preescaler es un divisor de

pulsos que está a la entrada del Timer-contador. El prescaler divide el número
de pulsos que le entran al timer-contador o al Wachtdog. El factor de división
es el siguiente (según los valores de PS2, PS1 y PS0 respectivamente

• PSA: Bit de asignación de prescaler. Si está a "1" el prescaler se asigna a

WDT (Wachtdog), si está a "0" se asigna al TMR0.
• TOSE: Bit de selección del tipo de flanco para el TMR0. A "1" se incrementa
TMR0 por flanco descendente de RA4, a "0" se incrementa TMR0 por flanco
ascendente de RA4.
• TOCS: Selecciona la entrada de reloj de TMR0. A "1" la entrada de reloj de
TMR0 es por flanco de la patilla RA4, a "0" la entrada de reloj de TMR0 es
por ciclo de reloj interno.

Pero el PIC también permite que se produzca una interrupción por desbordamiento
del TMR0.
Cuando se produce una interrupción el programa abandona temporalmente lo que
estaba haciendo para atender la subrutina de interrupción, pero antes guarda en

32
una región especial de la memoria llamada pila la dirección de la siguiente
instrucción de programa, para que cuando acabe la subrutina de interrupción pueda
seguir ejecutando el programa por donde se había quedado.

El registro que configura todas las interrupciones es el INTCON, como veis está
mapeado en los dos bancos, una cosa muy útil cuando se trabaja en ensamblador
para no tener que cambiar de banco constantemente para su configuración, pero
que en C no es necesario saber ya que es el compilador el que se encarga de
gestionar esto de una manera transparente para el programador.

Pues bien vamos a ver lo que significa cada uno de los bits que están implicados
en la interrupción por el TMR0:
• TOIF: solo se puede leer su valor, es un Flag o bandera que se pone a “1”
cuando se produce un desbordamiento del TMR0, (este o no este configurado
para producir una interrupción). Cuando se trabaja en Ensamblador, este bit
hay que ponerlo a "0" por programa, con CCS no tenemos que preocuparnos
por ello. (je, je,.. otra cosa que nos ahorramos)
• TOIE (Habilita la interrupción por desbordamiento de TMR0). Si este bit esta
a "1" la interrupción por desbordamiento de TMR0 es posible.
• GIE (Habilita las interrupciones globalmente). Este bit permite que cualquier
interrupción sea posible. Para poder usar cualquier interrupción hay que
habilitarla globalmente e individualmente.
Bueno como veis hay varias variables que podemos utilizar a nuestro antojo para
utilizar este recurso del PIC, la fórmula que las relaciona es la siguiente:

Y para ver como funciona todo esto con el compilador CCS vamos hacer el
siguiente ejemplo:
Se trata de usar el Timer0 para generar una interrupción cada 32 ms utilizando el
reloj interno del microcontrolador. La función de interrupción se utilizará para hacer
parpadear un Led en la patilla RB7 del PIC.
Para ello vamos a utilizar en el circuito un cristal de cuarzo de 4 MHz.
Si nos fijamos en la formula anterior tenemos Interrupt_TMR0= 32 ms que es el valor
que nos da el ejemplo, también tenemos F.Oscilador = 4 MHz y nos quedan dos
valores para tener resueltas todas las variables de la ecuación el valor TMR0 que
ya hemos dicho que se puede sobrescribir su valor en cualquier momento durante
la ejecución del programa y el Prescaler, pues le damos el valor que queramos al
Prescaler por ejemplo 256 y calculamos en la fórmula el valor que tenemos que
escribir en el registro TMR0 para obtener los 32 ms:

33
Practicas

1. Servomotor con timer0 #include

<16f877a.h>
#fuses xt,nowdt,noprotect,noput
#use delay (crystal=4M) int
conta=0,tiempo=0;

#int_timer0 void
timer_0()
{
tiempo=tiempo+1;

if(conta==tiempo) {
output_low(PIN_A0);
}
if(tiempo==40)
{output_high(PIN_A0); tiempo=0;
}

set_timer0(65510);//0.5ms
}

void servo (int grados)

{
if(grados==0) conta=1;
if(grados==90) conta=3;
if(grados==180) conta=5; }

34
void main()
{
setup_timer_0(rtcc_internal|rtcc_div_16);
set_timer0(65510);
enable_interrupts(int_timer0);
enable_interrupts(global); while(true)
{
servo(0);
delay_ms(2000);
servo(90);
delay_ms(2000);
servo(180);
delay_ms(2000);

}
}

2. Dos servomotores con timer0

#include <16f877a.h>
#fuses hs,nowdt,noprotect,noput
#use delay (crystal=4M) #BYTE
PORTD=0xF83
int conta=0,tiempo=0; int
conta1=0, tiempo1=0;
#int_timer0 void
timer_0()
{

35
 tiempo=tiempo+1;
tiempo1=tiempo1+1;

if(conta==tiempo)
{
output_low(pin_d0);
}

if(conta1==tiempo1)
{
output_low(pin_d1);
}
if(tiempo==40)
{
output_high(pin_d0);
tiempo=0;
}

if(tiempo1==40)
{
output_high(pin_d1);
tiempo1=0;
}

set_timer0(65510);//0.1ms
}

void servo (int grados)

{

36
 if(grados==180) conta=5;
if(grados==90) conta=3; if(grados==0)
conta=1;
}

void servo2 (int grados1)

{

if(grados1==90) conta1=3;
if(grados1==0) conta1=1;
if(grados1==180) conta1=5;
}

void main()
{
set_tris_d(0x00); setup_timer_0(rtcc_internal|rtcc_div_16);
set_timer0(65510); enable_interrupts(int_timer0); enable_interrupts(global);
while(true)
{

servo(180);
delay_ms(2000);
servo2(90);
delay_ms(2000); servo(90);
delay_ms(2000); servo2(0);
delay_ms(2000);

37
 }
}

3. Servomotores con teclado matricial y timer0

#include <16f877a.h>
#fuses xt,nowdt,noprotect,noput
#use delay (crystal=4M)
#define lcd_data_port getenv("sfr:portd")
#define lcd_enable_pin pin_d0
#define lcd_rs_pin pin_d1
#define lcd_rw_pi pin_d2
#define use_portb_kbd true
#include <kbd4x4.c> #include <lcd.c> char d; int x=0; int conta=0, tiempo=0;
char ser[3]; //vector donde se almacenaran los datos del keypad char
vector[3]={'0','0','0'}; //primer vector para 0° char ser1[3]; //vector
donde se almacenaran los datos para 90° char vector1[3]={'0','9','0'};
//segundo vector se compara para el giro a 90° char ser2[3]; //vector se
almacenan datos leidos del keypad char vector2[3]={'1','8','0'}; //vector a
comparar con datos leidos del keypad
#int_timer0 void
timer_0()
{
tiempo=tiempo+1;

if(conta==tiempo) {
output_low(PIN_A0);
}
if(tiempo==40)
{output_high(PIN_A0); tiempo=0;

38
 }

set_timer0(65510);//0.5ms
}

void servo (int grados)

{
if(grados==0) conta=1;
if(grados==90) conta=3;
if(grados==180) conta=5;

void main()
{
setup_timer_0(rtcc_internal|rtcc_div_16);
set_timer0(65510);
enable_interrupts(int_timer0);
enable_interrupts(global); lcd_init();
kbd_init(); set_tris_a(0x00);
port_b_pullups(true); inicio:
lcd_putc("\f Bienvenido ");
lcd_putc("\n Usuario");
delay_ms(1500);
lcd_putc("\fGrados Deseados:\n");
x=0; while(true)
{

39
 while(d!='#'){
while(x!=3){
d=kbd_getc(); if(d!=0){
ser[x]=d; ser1[x]=d;
ser2[x]=d; x++;
lcd_gotoxy(x,2);
printf(lcd_putc,"%c",d);
}
if(d=='*'){ goto
inicio;
}
}
d = kbd_getc();
}

if(ser[0]==vector[0]&&ser[1]==vector[1]&&ser[2]==vector[2]){
servo(0);
lcd_putc("\f Posicion\n");
lcd_putc(" 0 Grados");
delay_ms(2000); x=0;//Se iguala a
cero para que reinicie el proceso
d=0;//Se iguala a cero para que reinicie
el proceso goto inicio;
}

if(ser1[0]==vector1[0]&&ser1[1]==vector1[1]&&ser1[2]==vector1[2]){
servo(90);

40
 lcd_putc("\f Posicion\n");
lcd_putc(" 90 Grados");
delay_ms(2000); x=0;
d=0; goto inicio;
}

if(ser2[0]==vector2[0]&&ser2[1]==vector2[1]&&ser2[2]==vector2[2]){
servo(180); lcd_putc("\f Posicion\n"); lcd_putc(" 180 Grados");
delay_ms(2000); x=0; d=0; goto inicio;
}
}
}

Practica 10 Comunicación Serial

Marco Teórico

La comunicación serial es un protocolo muy común (no hay que confundirlo con el
Bus Serial de Comunicación, o USB) para comunicación entre dispositivos que se
incluye de manera estándar en prácticamente cualquier computadora. La mayoría
de las computadoras incluyen dos puertos seriales RS-232. La comunicación serial
es también un protocolo común utilizado por varios dispositivos para
instrumentación; existen varios dispositivos compatibles con GPIB que incluyen un
puerto RS-232. Además, la comunicación serial puede ser utilizada para adquisición
de datos si se usa en conjunto con un dispositivo remoto de muestreo.

El concepto de comunicación serial es sencillo. El puerto serial envía y recibe bytes

de información un bit a la vez. Aun y cuando esto es más lento que la comunicación
en paralelo, que permite la transmisión de un byte completo por vez, este método
de comunicación es más sencillo y puede alcanzar mayores distancias. Por ejemplo,
la especificación IEEE 488 para la comunicación en paralelo determina que el largo
del cable para el equipo no puede ser mayor a 20 metros, con no más de 2 metros
entre cualesquier dos dispositivos; por el otro lado, utilizando comunicación serial el
largo del cable puede llegar a los 1200 metros.

Típicamente, la comunicación serial se utiliza para transmitir datos en formato

41
ASCII. Para realizar la comunicación se utilizan 3 líneas de transmisión: (1) Tierra
(o referencia), (2) Transmitir, (3) Recibir. Debido a que la transmisión es asincrónica,
es posible enviar datos por un línea mientras se reciben datos por otra. Existen otras
líneas disponibles para realizar handshaking, o intercambio de pulsos de
sincronización, pero no son requeridas. Las características más importantes de la
comunicación serial son la velocidad de transmisión, los bits de datos, los bits de
parada, y la paridad. Para que dos puertos se puedan comunicar, es necesario que
las características sean iguales.

a. Velocidad de transmisión (baud rate): Indica el número de bits por segundo

que se transfieren, y se mide en baudios (bauds). Por ejemplo, 300 baudios
representa 300 bits por segundo. Cuando se hace referencia a los ciclos de
reloj se está hablando de la velocidad de transmisión. Por ejemplo, si el
protocolo hace una llamada a 4800 ciclos de reloj, entonces el reloj está
corriendo a 4800 Hz, lo que significa que el puerto serial está muestreando
las líneas de transmisión a 4800 Hz. Las velocidades de transmisión más
comunes para las lineas telefónicas son de 14400, 28800, y 33600. Es
posible tener velocidades más altas, pero se reduciría la distancia máxima
posible entre los dispositivos. Las altas velocidades se utilizan cuando los
dispositivos se encuentran uno junto al otro, como es el caso de dispositivos
GPIB.
b. Bits de datos: Se refiere a la cantidad de bits en la transmisión. Cuando la
computadora envía un paquete de información, el tamaño de ese paquete no
necesariamente será de 8 bits. Las cantidades más comunes de bits por
paquete son 5, 7 y 8 bits. El número de bits que se envía depende en el tipo
de información que se transfiere. Por ejemplo, el ASCII estándar tiene un
rango de 0 a 127, es decir, utiliza 7 bits; para ASCII extendido es de 0 a 255,
lo que utiliza 8 bits. Si el tipo de datos que se está transfiriendo es texto simple
(ASCII estándar), entonces es suficiente con utilizar 7 bits por paquete para
la comunicación. Un paquete se refiere a una transferencia de byte,
incluyendo los bits de inicio/parada, bits de datos, y paridad. Debido a que el
número actual de bits depende en el protocolo que se seleccione, el término
paquete se usar para referirse a todos los casos.
c. Bits de parada: Usado para indicar el fin de la comunicación de un solo
paquete. Los valores típicos son 1, 1.5 o 2 bits. Debido a la manera como se
transfiere la información a través de las líneas de comunicación y que cada
dispositivo tiene su propio reloj, es posible que los dos dispositivos no estén
sincronizados. Por lo tanto, los bits de parada no sólo indican el fin de la
transmisión sino además dan un margen de tolerancia para esa diferencia de
los relojes. Mientras más bits de parada se usen, mayor será la tolerancia a
la sincronía de los relojes, sin embargo la transmisión será más lenta.
d. Paridad: Es una forma sencilla de verificar si hay errores en la transmisión
serial. Existen cuatro tipos de paridad: par, impar, marcada y espaciada. La
opción de no usar paridad alguna también está disponible. Para paridad par
e impar, el puerto serial fijará el bit de paridad (el último bit después de los

42
 bits de datos) a un valor para asegurarse que la transmisión tenga un número
par o impar de bits en estado alto lógico. Por ejemplo, si la información a
transmitir es 011 y la paridad es par, el bit de paridad sería 0 para mantener
el número de bits en estado alto lógico como par. Si la paridad seleccionada
fuera impar, entonces el bit de paridad sería 1, para tener 3 bits en estado
alto lógico. La paridad marcada y espaciada en realidad no verifican el estado
de los bits de datos; simplemente fija el bit de paridad en estado lógico alto
para la marcada, y en estado lógico bajo para la espaciada. Esto permite al
dispositivo receptor conocer de antemano el estado de un bit, lo que serviría
para determinar si hay ruido que esté afectando de manera negativa la
transmisión de los datos, o si los relojes de los dispositivos no están
sincronizados.

LabVIEW

LabVIEW es un software de ingeniería diseñado para aplicaciones que requieren

pruebas, medidas y control con acceso rápido a información de datos y hardware.

LabVIEW (acrónimo de Laboratory Virtual Instrument Engineering Workbench) es

una plataforma y entorno de desarrollo para diseñar sistemas, con un lenguaje de
programación visual gráfico. Recomendado para sistemas hardware y software de
pruebas, control y diseño, simulado o real y embebido, pues acelera la
productividad. El lenguaje que usa se llama lenguaje G, donde la G simboliza que
es lenguaje Gráfico.
Este programa fue creado por National Instruments (1976) para funcionar sobre
máquinas MAC, salió al mercado por primera vez en 1986. Ahora está disponible
para las plataformas Windows, UNIX, MAC y GNU/Linux. La penúltima versión es la
2013, con la increíble demostración de poderse usar simultáneamente para el
diseño del firmware de un instrumento RF de última generación, a la programación
de alto nivel del mismo instrumento, todo ello con código abierto. Y posteriormente
la versión 2014 disponible en versión demo para estudiantes y profesional, la versión
demo se puede descargar directamente de la página National Instruments.
Los programas desarrollados con LabVIEW se llaman Instrumentos Virtuales, o VIs,
y su origen provenía del control de instrumentos, aunque hoy en día se ha expandido
ampliamente no sólo al control de todo tipo de electrónica (Instrumentación
electrónica) sino también a su programación embebida, comunicaciones,
matemáticas, etc. Un lema tradicional de LabVIEW es: "La potencia está en el
Software", que con la aparición de los sistemas multinúcleo se ha hecho aún más
potente. Entre sus objetivos están el reducir el tiempo de desarrollo de aplicaciones
de todo tipo (no sólo en ámbitos de Pruebas, Control y Diseño) y el permitir la
entrada a la informática a profesionales de cualquier otro campo. LabVIEW consigue

43
combinarse con todo tipo de software y hardware, tanto del propio fabricante -
tarjetas de adquisición de datos, PAC, Visión, instrumentos y otro Hardware- como
de otros fabricantes.

Practicas

1. Encender y apagar un led por medio de LabVIEW

#include <16f877a.h>
#fuseS xt,nowdt, noprotect
#use delay(crystal = 4Mhz)

#use rs232(BAUD=9600, PARITY=N, XMIT=PIN_C6, RCV=PIN_C7,bits=8)

int8 dato; void main(){ set_tris_a(0x00); output_d(0);

while(true){
dato=getc(); putc(dato);

if(dato=='1'){
output_high(pin_a0);
} else{
if(dato=='0'){
output_low(pin_a0);
}
}
}

44
 2. Escribir en un LCD por medio de LabVIEW

#include <16f877a.h>
#fuses xt, nowdt, noprotect, noput, nolvp
#use delay(crystal = 4Mhz)
#define lcd_port_d true
#define lcd_enable_pin pin_d0
#define lcd_rs_pin pin_d1
#define lcd_rw_pin pin_d2
#include <lcd.c>
#use rs232(BAUD=9600, PARITY=N, XMIT=PIN_C6, RCV=PIN_C7,bits=8)
char dato; char write; int i=0;

void main(){ lcd_init();

set_tris_a(0x00);
output_high(pin_a0);
delay_ms(1500);
output_low(pin_a0);
i=0;

while(true){
dato=getc();

switch(dato){
case '1':
while(dato=='1'){
write=getc(); if(i<=16){

45
i++; lcd_gotoxy(i,1);
printf(lcd_putc,"%c",write);
}
else if(i>=17){
i=0; dato=getc();
}
}
break;
case '2':
while(dato=='2'){
write=getc(); if(i<=16){
i++; lcd_gotoxy(i,2);
printf(lcd_putc,"%c",write);
}
else if(i>=17){
i=0; dato=getc();
}
}
break;
case '3':
lcd_putc("\f");
i=0; write=0;

break;
}
}

46
 }

Practica 11 pulse-width modulation (PWM)

La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés
de pulse-width modulation) de una señal o fuente de energía es una técnica en la
que se modifica el ciclo de trabajo de una señal periódica (una senoidal o una
cuadrada, por ejemplo), ya sea para transmitir información a través de un canal de
comunicaciones o para controlar la cantidad de energía que se envía a una carga.

La construcción típica de un circuito PWM se lleva a cabo mediante un comparador

con dos entradas y una salida. Una de las entradas se conecta a un oscilador de
onda dientes de sierra, mientras que la otra queda disponible para la señal
moduladora. En la salida la frecuencia es generalmente igual a la de la señal dientes
de sierra y el ciclo de trabajo está en función de la portadora.
La principal desventaja que presentan los circuitos PWM es la posibilidad de que
haya interferencias generadas por radiofrecuencia. Estas pueden minimizarse
ubicando el controlador cerca de la carga y realizando un filtrado de la fuente de
alimentación.

En los motores
La modulación por ancho de pulsos es una técnica utilizada para regular la velocidad
de giro de los motores eléctricos de inducción o asíncronos. Mantiene el par motor
constante y no supone un desaprovechamiento de la energía eléctrica. Se utiliza
tanto en corriente continua como en alterna, como su nombre lo indica, al controlar:
un momento alto (encendido o alimentado) y un momento bajo (apagado o
desconectado), controlado normalmente por relés(baja frecuencia) o MOSFET o
tiristores (alta frecuencia).
Otros sistemas para regular la velocidad modifican la tensión eléctrica, con lo que
disminuye el par motor; o interponen una resistencia eléctrica, con lo que se pierde
energía en forma de calor en esta resistencia.
Otra forma de regular el giro del motor es variando el tiempo entre pulsos de
duración constante, lo que se llama modulación por frecuencia de pulsos.

47
En los motores de corriente alterna también se puede utilizar la variación de
frecuencia.
La modulación por ancho de pulsos también se usa para controlar servomotores, los
cuales modifican su posición de acuerdo al ancho del pulso enviado cada un cierto
período que depende de cada servo motor. Esta información puede ser enviada
utilizando un microprocesador como el Z80, o un microcontrolador (por ejemplo, un
PIC 16F877A, 16F1827, 18F4550, etc. de la empresa Microchip), o un
microcontrolador de hardware libre como es Arduino.

48
Practicas

1. Aumentar y disminuir la intensidad de un led

#include <16f877a.h>
#fuses xt, nowdt, noprotect, nolvp
#use delay(crystal=4Mhz) int16
duty=0;

void main(){

set_tris_d(0x00); //Configuracion
del Timer2
setup_timer_2(t2_div_by_16,124,1);//Valor a cargar en el Timer2=124, Valor del
Poscaler=1 setup_ccp1(ccp_pwm);

while(true){
for(duty=1;duty<=500;duty++){
delay_ms(10); set_pwm1_duty(duty);
}
for(duty=500;duty>=1;duty--){
delay_ms(10); set_pwm1_duty(duty);
}

}
}

49
Conclusión

Resumiendo, el campo de microcontroladores ha evolucionado desde su origen

junto con las computadoras y otros aparatos electrónicos. Este tema se relaciona
con las áreas de Nanotecnología, Robótica, Electrónica, Física, Informática y
Computación, teniendo como objetivo llevar a cabo procesos lógicos o acciones
programadas en lenguaje ensamblador por un usuario o programador. Cuenta con
tres diferentes tipos los cuales se clasifican por bits, por arquitectura y finalmente
por software. Los microcontroladores cuentan con una gran variedad de
aplicaciones, las mayores aplicaciones se encuentran reflejadas en el campo de la
industria automotriz y en segundo lugar se puede ver el campo de la arquitectura y
funcionamiento del termostato digital. La prospectiva de este tema indica que este
tema seguirá evolucionando de manera progresiva a través de los años y con las
mejoras que vengan en el campo de dispositivos como lo son los
microcontroladores, ya que estos ayudan a terminar procesos mucho más
rápidamente.

El campo de microcontroladores es un campo de estudio importante en el estudio

para las futuras generaciones debido a que siempre existirá la necesidad de que
aparatos electrónicos funcionen cada vez más rápido y que su tecnología en
microchips sea cada vez de tamaño más reducido sin disminuir la velocidad.

50
Referencias Bibliográficas

https://sites.google.com/site/ielimcortezjesusantonio/5-conclusiones/5-4-conclusion

https://www.mikroe.com/ebooks/microcontroladores-pic-programacion-en-c-
conejemplos/lenguajes-de-programacion

https://www.mikroe.com/ebooks/microcontroladores-pic-programacion-en-c-
conejemplos/puertos-de-entradasalida

https://entrrnadorpic16f84.wordpress.com/4-puertos-de-entrada-y-salida/

https://www.unioviedo.es/ate/alberto/TEMA4-puertos.pdf

51