Dr. Julio J. Mendoza H.

0412-5620807 [email protected]

PROGRAMACIÓN EN LENGUAJE C

Este material pretende proporcionar o potenciar conocimientos acerca de las formas y aplicaciones
de las estructuras básicas de programación en Lenguaje C bajo el entorno MPLAB y el compilador
XC8, no de sustituir un libro de texto. Sin embargo, la destreza que pueda adquirir el lector de este
material se incrementa considerablemente en la cantidad de tiempo de compromiso intelectual que
el lector pueda dedicarle a la práctica de las estrategias de programación directamente en la
computadora.

USO DE COMENTARIOS
Los Comentarios permiten la documentación del código (especificar para qué sirve cada línea de
programa). Puede seleccionarse un bloque comenzando por /* y finalizando el bloque con */ o
agregando // al principio de la línea para volverla comentario hasta su final. Por ejemplo, los
comentarios se colocan de acuerdo a la siguiente sintaxis:
/* Este es un comentario de todo lo que se encuentre entre los caracteres */
// Este también es un comentario pero solo hasta el final de la línea

INICIO Y FIN DE BLOQUE

La implementación de llaves en un programa indica el inicio o fin de bloque, permitiendo agrupar
un número de instrucciones que pueden ser ejecutadas con cierta prioridad. Se usa { para iniciar
bloque y } para finalizar bloque. Se emplean cuando una estructura condicional o ciclo repetitivo
necesita ejecutar más de una instrucción:
{ // inicio de bloque
// se colocan las instrucciones deseadas
} // final de bloque

VARIABLES

Las variables son herramientas informáticas que se usan para almacenar

temporalmente información y ocupan espacios en la memoria RAM. El
nombre asignado a una variable está sujeto a la voluntad del programador
y está relacionado directamente con la posición que ocupa esta variable en
la memoria. Por ejemplo, al declarar una variable de tipo entero con el
nombre de VARINT, el µC le proporciona a) un espacio de memoria que
depende del tipo de datos que se desea almacenar en ella y b) una dirección de memoria específica.
Es similar a pensar que la variable es la casa de una urbanización y el habitante de la casa es la

Página 1 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

información almacenada en la variable (o sea, cuánto vale). Entonces, cuando se quiere hacer
referencia o buscar la información contenida en la variable, se puede preguntar por la casa o por la
dirección donde se encuentra ubicada la casa. Estas dos maneras de hacer referencia a una variable
se denominan Direccionamiento Directo (haciendo referencia directamente al nombre de la
variable) o Direccionamiento Indirecto (haciendo referencia a la dirección de memoria donde se
encuentra ubicada la variable.

Un µC asigna cierta cantidad de espacio de memoria RAM a una variable en dependencia al tipo de
variable que se desea crear. Por ejemplo, un caso muy común es disponer de un µC que posee
espacios de memoria de 8 bits (1 byte c/u), entonces para almacenar una variable de tipo “char”
utiliza un espacio completo de su memoria, pero si desea almacenar variables de tipo “int” o “float”
debe disponer de 2 espacios y 4 espacios de su memoria, respectivamente. El espacio que ocupa
cada tipo de variable en la memoria de un µC se puede visualizar en la siguiente tabla (8 bits
equivalen a 1 byte):

TIPO DESCRIPCION TAMAÑO EN BITS RANGO DE VALORES

bit bit 1 0a1
char caracter 8 -128 a 127
unsigned char caracter sin signo 8 0 a 255
short entero 16 -32.768 a 32.767
unsigned short entero sin signo 16 0 a 65.535
int entero 16 -32.768 a 32.767
unsigned int entero sin signo 16 0 a 65.535
long entero 32 -2.147.483.648 a 2.147.483.647
unsigned long entero sin signo 32 0 a 4.294.967.295
float flotante simple 32 ±1.176 ·10^-38 a ±6.81 ·10^38
double flotante doble 64 ±1.175 ·10^-38 a ±6.81 ·10^38

Por el contrario, si un µC posee espacios de memoria de 16

bits (2 bytes), entonces para almacenar una variable de tipo
“char” utiliza solo medio espacio de su memoria y al
almacenar variables de tipo “int” o “float” debe disponer de 1
espacios y 2 espacios de su memoria, respectivamente. En la
imagen se observa que existe una variable con el nombre
“temperatura” de tipo “int” y ocupa una posición completa en
la memoria, la variable con el nombre “primera_letra” de tipo
“char” solo ocupa medio espacio y “longitud” de tipo “float” ocupa 2 espacios en la memoria.

Hay que resaltar que cada variable ocupa una posición en la memoria, o sea que dos variables no
ocupan una misma posición, como en la figura anterior donde una variable ‘A’ tipo “char” ocupa
media posición en la memoria de un µC de 16 bits y los otros 8 bits no son aprovechados. Imagine el
caso donde dos variables diferentes (A y B) de tipo “char” compartan la misma posición de memoria
ya que ocupan cada una medio espacio: entonces cuando se haga el direccionamiento indirecto no
se sabría cual valor se está devolviendo, el valor de A o B. De hecho, el programa creerá que en
realidad es una sola variable de tipo “int” que ocupa toda la posición, y no dos variables “char” que
comparten la posición.

Página 2 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

OPERACIONES CON VARIABLES

Las operaciones entre variables empleadas en Lenguaje C son similares a las operaciones
aritméticas que cotidianamente se realizan: Existen a) dos miembros (el miembro izquierdo
almacena el resultado de la operación y el miembro derecho calcula), b) “n” cantidad de operandos y
c) “n-1” cantidad de operadores; donde cada operador debe estar entre dos operandos.

Si en una operación aritmética se involucran variables del mismo tipo, entonces el resultado será
una variable del mismo tipo. Por el contrario, si variables de diferentes tipos son usadas en una
misma operación aritmética, el resultado debe ser almacenado en una variable de igual o mayor
capacidad que la variable con mayor capacidad en la operación. Por ejemplo, si se suma una variable
tipo “char” con una variable tipo “int” y la variable donde se almacena el resultado es de tipo “int” o
“float”, el resultado de la operación será de tipo “int” o “float” sin problemas porque estos formatos
tienen mayor capacidad. Sin embargo, existen casos donde el resultado de un cálculo se pretende
almacenar en una variable cuya capacidad es inferior a la capacidad de la variable involucrada en el
cálculo, entonces el resultado de la operación se ajusta al tipo de la variable resultado.

bit < char < int < long < float < double

Por ejemplo, si se desea almacenar el valor 3,14 en una variable tipo “char” o “int”, entonces se
almacenará únicamente el valor 3, ya que este tipo de variables no tiene la capacidad de almacenar
decimales, como una variable tipo “float”, por ejemplo. Otro caso sería almacenar un valor como
2019 en una variable tipo “unsigned char” cuyo formato solo puede almacenar números hasta 255.
Debido a que 2019 excede la capacidad de la variable donde se desea almacenar, el resultado sería
que se almacena el valor 234, que lógicamente no es lo que se esperaba.

Para realizar operaciones aritméticas entre variables se emplean los operadores comúnmente
usados y otros operadores especiales creados para el Lenguaje C. Estos operadores debe colocarse
en la ecuación entre dos variables, dos constantes o una variable y una constante. Es importante
mencionar que para que un cálculo aritmético que involucra solo variables de tipo “char” o “int” o
constantes enteras resulte un número decimal para asignarlo a una variable de tipo “float”, hay que
incorporar alguna constante que tenga un punto decimal, para que el lenguaje pueda interpretar
que el resultado que se quiere es decimal. En caso contrario, el valor resultante no será el esperado.

OPERADOR ARITMÉTICO OPERACIÓN RESULTADO

= Igual a Cálculo realizado

+ Adición Suma de los operandos

- Sustracción Resta de los operandos

* Producto Multiplicación de los operandos

/ Cociente División de los operandos

% Módulo Resto de la división

Página 3 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

OPERADORES RELACIONALES
Se usan en las proposiciones de control de los ciclos y las estructuras condicionales. Se incorporan
para comparar variables entre sí o variables con constantes. En ocasiones se olvida colocar “doble
igual” para comparar la igualdad entre dos expresiones, por lo que el compilador avisa como
warning que es posible que falte un igual; ya que es una comparación y no asignación.

OPERADOR SIGNIFICADO EJEMPLO LA CONDICIÓN ES VERDADERA

> Es mayor que b>a Si b es mayor que a

>= Es mayor o igual que a >= 5 Si a es mayor o igual que 5

< Es menor que a<3 Si a es menor que 3

<= Es menor o igual que a <= b Si a es menor o igual que b

== Es igual a a == 6 Si a es igual a 6
No es igual a (es
!= a != b Si a es diferente de b
diferente)

Los operadores lógicos se usan para comprobar proposiciones. Un cero (0) indica que la condición
no se cumple o es falsa y un uno (1) indica que la condición se cumple o es verdadera. Según sea su
uso, el resultado de la operación lógica “&&” u “||” será verdadera o falsa en correspondencia con las
respectivas tablas de verda. El operador lógico “!” simplemente niega la condición lógica.

OPERADORES BITWISE

OPERANDO SIGNIFICADO EJEMPLO RESULTADO

Complemento o negador de
~ a = ~b b=5 a = -5
bits
Rota un número de bits a la
<< a = b << 2 b = 11110011 a = 11001100
izquierda
Rota un número de bits a la
>> a = b >> 1 b = 11110011 a = 01111001
derecha
Aplica el comparador lógico a = 11100011
& "Y" entre los bits de dos c=a&b c = 11000000
variables b = 11001100
Aplica el comparador lógico a = 11100011
| "o" entre los bits de dos c=a|b c = 11101111
variables b = 11001100
Aplica el comparador lógico a = 11100011
^ "o exclusiva" entre los bits de c=a^b c = 00101111
dos variables b = 11001100

Página 4 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

Los operadores bitwise se utilizan para hacer operaciones lógicas entre los bits de las variables
usadas como operandos. Es común hacer operaciones bitwise entre los bits de una variable y los
bits de una constante. Por ejemplo, se puede emplear & 0xF0 para seleccionar el nibble alto de una
variable o se puede emplear & 0x0F para seleccionar el nibble bajo de una variable. Hay que resaltar
que estos operadores se usan sobre bits, no sobre proposiciones, o sea que & es diferente a && y | es
diferente a ||.

Otra forma práctica de usar un operador bitwise es rotar los bits de una variable a la derecha
usando >> o a la izquierda usando <<. Cada vez que se rota un bit a la derecha es equivalente a
realizar sobre la variable una división por 2, o sea que la expresión A>>4 es equivalente a A/16, o
A/24. Por el contrario, cada vez que se rota un bit a la izquierda es equivalente a realizar sobre la
variable una multiplicación por 2, o sea que la expresión A<<3 es equivalente a A*8, o A*23.

ESTRUCTURA BÁSICA DE UN PROGRAMA

LINEA DE COMANDO SIGNIFICADO PARA EL PROGRAMADOR

INCLUSIÓN DE LIBRERIAS Indica que se hará uso de la librería denominada “xc.h”, en la cual se
establecen las definiciones básicas de operación para los diferentes µCs
#include <xc.h> soportados en ella. No es necesario (como en otros ambientes) incluir la
librería de cada µC.
DEFINICIÓN DE LA VELOCIDAD DEL Establece la velocidad a la cual se hará referencia como base de cálculo
CRISTAL
para establecer el tiempo de ejecución de las instrucciones del programa,
principalmente los ciclos de espera. Se usa la frecuencia del cristal
#define _XTAL_FREQ implementado en el diseño.
CONFIGURACIÓN DE PARÁMETROS Define los parámetros básicos de operación del µC tales como FOSC
BÁSICOS DE OPERACIÓN
(frecuencia de oscilación del cristal) o WDTE (habilitación del perro
guardián) entre otros. Haciendo clic sobre la pestaña “Production” y “Set
#pragma config configuration bits” es posible cambiar el valor de estos parámetros en
coherencia con el diseño físico implementado, para luego cortar y pegar
en el programa.
DEFINICÓN DE PINES ESPECIALES Esta estructura asigna un NOMBRE a cualquier PIN del µC. Por ejemplo,
si el diseño físico incorpora un pulsador conectado al pin 4 del puerto A
del µC, se puede definir:
#define NOMBRE PIN #define PUL RA4 // familias 12 o 16
#define PUL PORTAbits.RA4 // familia 18
y usar PUL en lugar de PORTAbits.RA4 en todo el programa. En la familia
12 o 16 es posible definir solo con RA4, pero en la 18 hay que colocar
PORTAbits.RA4. Se recomienda colocar nombres coherentes a las
funciones de cada pin, tales como PUL, INC, DEC, Modo, OK, LED, botón,
Luz, motor, Bomba, entre otros.
DECLARACIÓN DE FUNCIONES En esta sección del programa sólo se colocan los encabezados de las
funciones que se usaran en el programa culminadas con punto y coma.
tipo NOM (tipo PAR); Debe colocarse el tipo de la función (char, int, entre otras) o void si no
devuelve un valor, seguido de un espacio y el nombre que identifica la
función (NOM) y finalmente dentro de paréntesis los parámetros (PAR)
con sus tipos. Los parámetros son valores que la función necesita para
funcionar correctamente, se coloca void en caso de no necesitar.

Página 5 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

DECLARACIÓN DE VARIABLES La declaración de las variables globales se realiza colocando primero el

tipo (char, unsigned char, int, unsigned int o float) seguido por el nombre
tipo NOM; de la variable (NOM), la cual puede ser inicializada o no. Existen otros
tipos de variables, sin embargo las mostradas son las más usadas. Este
char Contador, I; lenguaje es Case Sensitive, por lo que una variable ABC será diferente a
unsigned char LED, ant = 0; Abc o abc; ya que reconoce entre mayúsculas y minúsculas. Las variables
int NUMERO; pueden declararse antes del cuerpo principal (globales) o en cada
función (locales). Hay otra forma de declarar variables y es colocarle el
unsigned int ADC, aux;
tipo antes de usarlas en el programa por primera vez, pero esta
float Calculo=0; estrategia es poco convencional entre los nuevos programadores.
CUERPO PRINCIPAL DEL PROGRAMA El cuerpo principal del programa se establece al colocar la instrucción
void main (void), la cual indica que es por aquí donde se comenzarán a
void main (void) ejecutar las instrucciones, según el orden y estructuras lógicas que se
{ incluyan dentro de las llaves. Si un programa carece de esta sección, el
Instrucciones compilador no encontrará por donde comenzar a ejecutar el programa.
} Hay programas que no tienen cuerpo principal, como las librerías.
FUNCIONES Al finalizar el cuerpo principal del programa es necesario desarrollar
completamente las funciones que van a ser usadas durante la ejecución
tipo NOM (tipo PAR) del cue3rpo principal y las instrucciones que las componen. El tipo de las
{ funciones puede ser void (en caso de no devolver un valor) o cualquier
Instrucciones otro conocido. Asimismo si no requiere algún parámetro de operación se
} coloca void. Si el tipo de la función es distinta a void, entonces se debe
usar la instrucción return al culminar el cuerpo de la función a modo de
devolver el parámetro deseado.

ESTRUCTURA DEL CUERPO PRINCIPAL

void main (void) // aquí comienza el programa

{

/*************** CONFIGURACION DE PINES (1=entrada 0=salida) **************/

TRISA = 0b00001111; // configura RA0-RA3 como entradas y RA4-RA7 como

TRISB = 0b11000001; // salidas y configura RA1-RA5 como salidas y RA7,
// RA6 y RA0 como entradas.

/******************* INICIALIZACION DE PINES (1=5V 0=0V) *********************/

PORTA = 0; // asigna 0 a todos los pines del PUERTO A = 0V

PORTB = 0b00110000; // asigna 1 a los pines RB4 y RB5 = 5V, los demás 0V
// Depende de la lógica usada.

// Se configuran los registros de operación del ADC, interrupciones, temporizadores

// comunicaciones, según las propiedades del µC y las necesidades del diseño

/******************************* CICLO INFINITO ********************************/

Página 6 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

while(1)
{
// Instrucciones a ejecutar
} // fin del ciclo infinito
} // fin del cuerpo principal

ESTRUCTURAS BÁSICAS DE OPERACIÓN LÓGICA

NOCIONES INICIALES:
 Si la estructura de operación posee solo una acción a ejecutar, se puede colocar esta acción
entre llaves o no. En caso de querer ejecutar más de una acción, deben colocarse llaves para
indicar dónde comienza y termina la estructura.
 Las condiciones (o proposiciones) son de tipo BOOLEANO, o sea, solo pueden adoptar dos
valores: 0=falso o 1=verdadero. Si el valor es 1 o verdadero se cumplirá la condición y las
instrucciones dentro de la estructura se ejecutarán, en caso que la condición sea 0 o falsa no
se ejecutarán las acciones de la estructura y el programa saltará a la próxima instrucción.
 El operador && aplica la conjunción entre dos condiciones y el operador || aplica la
disyunción entre dos condiciones. Es posible combinar dos o más condiciones o
proposiciones con estos operadores.
 Una condición correcta se realiza cuando se emplean dos operandos y un operador. Los
operandos pueden ser variables o números y los operadores ==, !=, <, <=, >, >=, por ejemplo:
Var1==123, Var>2, 89!=Contador, ADC==ADC_ANTERIOR. En este lenguaje se usan los
operandos a los extremos y el operador lógico en medio de los operandos.

ESTRUCTURA CONDICIONAL if

TOPOLOGÍA: if (condición)

USO: Se utiliza en casos donde se requiere realizar una acción en dependencia del valor de la
variable que establece la condición. Se recomienda usar esa estructura cuando la variable de la
condición presenta solo dos alternativas, tal como el estado de un pulsador o botón (0: no
presionado y 1: presionado), un sensor on-off de nivel (0: activo y 1: no activo). En caso contrario se
debe implementar una estructura con if anidados.

EJEMPLO 1: Si solo se desea realizar una acción si se cumple la condición:

/* si el pulsador se presiona por lo menos una vez se enciende el led LED indefinidamente porque
no existe una instrucción que lo apague, o sea, LED = 0**/

if (PUL == 1) // note que == es para comparar el valor de PUL con 1 lógico

LED = 1; // pero = es para asignar un valor 1 a LED

Página 7 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

EJEMPLO 2: Si desea realizar dos o más acciones si se cumple la condición:

/* si el pulsador se presiona por lo menos una vez se enciende el led LED indefinidamente porque
no existe una instrucción que lo apague, o sea, LED = 0**/

if (PUL == 1) // compara si el pulsador es presionado

{
LED = 1; // enciende LED asignando 1 (lógica positiva)
MOTOR = 0; // apaga MOTOR asignando 0 Lógica positiva)
}

EJEMPLO 3: Se realiza una acción si se cumple la condición u otra acción si no se cumple la

condición:

/**** solo cuando el pulsador está presionado enciende el led LED *****/

if (PUL == 1) // si el pulsador es presionado

LED = 1; // enciende LED
else // “en caso contrario” o sea cuando el pulsador no está presionado
LED = 0; // apaga LED

EJEMPLO 4: Se realizan acciones si se cumplen dos condiciones simultáneamente y otras

acciones si no se cumple cualquiera de estas condiciones:

if ((PUL == 1)&&(ENERGIA==1)) // si el pulsador es presionado y hay energía al mismo tiempo

{
MOTOR = 1; // enciende MOTOR
ALARMA = 0; // apaga ALARMA
}
else // si el pulsador no fue presionado o no hay energía
{
MOTOR = 0; // apaga MOTOR
ALARMA = 1; // enciende ALARMA
}

EJEMPLO 5: Cuando se deben chequear dos condiciones pero no se quiere utilizar && se pueden
usar if anidados, o sea, un if dentro de otro if:

if (contador == 10) // si contador es igual a 10

if (Clave ==1234) // si Clave es igual al valor 1234
PUERTA = 1; // asigna 1 a PUERTA si se cumplen las dos condiciones

Es igual utilizar:

Página 8 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

if ((contador == 10)&&(Clave ==1234)) // si contador es 10 y Clave alcanzó 1234

PUERTA = 1; // asigna 1 a PUERTA

EJEMPLO 6: Cuando no se quiere utilizar && se pueden usar if anidados:

if (MENU == 0) // si la variable MENU alcanzó el valor 0

{
if (INC ==1) // si INC es igual a 1
CONT++; // incrementa CONT
if (DEC ==1) // si DEC es igual a 1
CONT--; // decrementa CONT
}

Es igual utilizar if separados:

if ((MENU == 0)&&(INC ==1)) // si MENU es 0 e INC es 1

CONT++; // incrementa CONT
if ((MENU == 0)&&(DEC ==1)) // si MENU es 0 y DEC es 1
CONT--; // decrementa CONT

Es igual utilizar:

if (MENU == 0) // si MENU alcanzó el valor 0

if (INC ==1) // si INC alcanzó el valor 1
CONT++; // incrementa CONT
if (MENU == 0) // si MENU alcanzó el valor 0
if (DEC ==1) // si DEC alcanzó el valor 1
CONT--; // decrementa CONT

ESTRUCTURA CONDICIONAL switch

TOPOLOGÍA:
switch(variable)
{
case 0: { /*acciones a realizar*/ break; }
case 1: { /*acciones a realizar*/ break; }

case n: { /*acciones a realizar*/ break; }

default: { /*acciones a realizar*/ break; }
}

USO: Se utiliza en casos donde se requiere la variable a discriminar adquiere más de dos valores. La
variable puede tomar “n” valores y la opción “default” especifica que hacer en los casos no
contemplados. Note que cada caso tiene sus propias llaves y su propio break, ya que con una sola

Página 9 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

instrucción y el break se convierten en dos acciones y debe implementar llaves. La instrucción break
se coloca para indicarle al compilador que aborte la estructura switch una vez que ejecute las
acciones propias del caso. En el siguiente ejemplo la estructura switch verifica el valor de la variable
CONT y ejecuta las acciones dependiendo de lo contemplado en la coincidencia de caso.

EJEMPLO 1:

switch(CONT)
{
case 0: { LED1 = 0; LED2 = 0; break; }
case 1: { LED1 = 1; LED2 = 0; break; }
case 2: { LED1 = 1; LED2 = 0; break; }
default: { LED1 = 1; LED2 = 1; break; }
}

Esta estructura se utiliza para acortar las líneas de programación y visualizar eficientemente los
casos. En lugar de un switch, se podría usar esta secuencia de if:

if (CONT==0)
{ LED1 = 0; LED2 = 0; }
if (CONT==1)
{LED1 = 1; LED2 = 1; }
if (CONT==2)
{LED1 = 0; LED2 = 1; }
if (CONT>=3)
{LED1 = 1; LED2 = 1;}

EJEMPLO 2: if dentro de switch:

switch(MENU)
{
case 0: {
if (INC)
{ NUM1++; __delay_ms(250); }
if (DEC)
{ NUM1--; __delay_ms(250); }
break;
}
case 1: {
if (!OK)
NUM = 255;
else
{ AUX = NUM; __delay_ms(250); }
break;
}
}

Página 10 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

EJEMPLO 3: switch dentro de if:

if(5<=CONT)&&(CONT <10))
switch(CONT)
{
case 5: { PORTA = CONT; break;}
case 6: { PORTB = CONT; break;}
case 7: { LED_ROJO = 1; break;}
case 8: { LED_VERD = 1; break;}
case 9: {continue; break;}
}
else
{
PORTA = 0;
PORTB = 0;
LED_ROJO = 0;
LED_VERD = 0;
}

En cualquier caso, el programador selecciona cual es la estructura a usar, ya sea if o switch. Se

recomienda usar el switch cuando las alternativas de una variable sean más de dos, sino use if. La
implementación de opción “default” del switch no es obligatoria. También es funcional combinar
estructuras condicionales donde pudiera ir switch dentro de if, o if dentro de switch.

ESTRUCTURA REPETITIVA for

TOPOLOGÍA:
for(Valor_Inicial; Condición; Forma)
{
//Acciones a ejecutar
}

USO: Se utiliza en casos donde se conoce la cantidad de veces que se desea ejecutar una acción. La
cantidad de veces que se repetirá este ciclo depende del valor de una variable entera (unsigned char
o unsigned int) Posee 3 parámetros:

1. Valor_Inicial: Por ejemplo, I=0 especifica que la variable que controla el ciclo es “I” y su
valor inicial es 0 en este caso.

2. Condición: Por ejemplo, I<7 especifica que el ciclo se repetirá siempre que la variable “I” sea
menor a 7 en este caso.

3. Forma: Indica la manera como se modificará la variable que controla el ciclo. Por ejemplo,
I++ indica que la variable se incrementará en una unidad cada vez que se repita el ciclo. En
caso que la Forma sea I—2 especifica que la variable que controla el ciclo “I” reducirá su
valor en 2 unidades cada vez que se repita el ciclo.

Página 11 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

EJEMPLO 1: Al Puerto C del µC se le asigna el valor de la variable “I” que controla el ciclo. Se
desea repetir el ciclo 200 veces, partiendo de cero y que la variable se incremente de uno en
uno.

for (I=0;I<200;I++)
PORTB = I;

EJEMPLO 2: Se desea encender 30 veces y apagar 30 veces un diodo led conectado al µC y que
encienda y apague cada 5 segundos.

for(x=0; x<60; x++)

{
if(LED==0) // si el Led está apagado
LED = 1; // se enciende
else //si el LED está encendido
LED = 0; //se apaga
__delay_ms(5000); // la espera no se encuentra dentro del condicional
}
EJEMPLO 3: Se desea invertir los valores binarios de una variable unsigned char llamada “A” y
que sean guardados en una variable unsigned char llamada “B”.

for (J=0;J<8;J++) // comienza en 0 y termina en 7: se repite 8 veces

{
Caja = A; // se asigna el valor completo de A
Caja = Caja&0b00000001; // se aplica una & para dejar solo el último bit
B = B<<1; // se rota B hacia la derecha un lugar
B = B+ Caja; // se suma B y Caja
A = A>>1; // se rota A hacia la izquierda un lugar
}

EJEMPLO 4: Se desea enviar uno a uno los valores de una variable unsigned char llamada “A”
(comenzando por el último valor) a través del pin 7 del puerto B del µC.

for (K=1;K<=8;K++) // comienza en 1 y termina en 8: se repite 8 veces

{
RB7 = A&0b00000001; // se asigna el valor de A y se aplica & bitwise
A = A>>1; // se rota A hacia la izquierda un lugar
}

EJEMPLO 4: Se desea enviar uno a uno los valores de una cadena de valores unsigned char
llamada “CAD” a través del puerto C del µC comenzando por el primero.

for (I=0;CAD[I]!=’\0’;I++) // repite el ciclo hasta que el carácter

PORTC = CAD[I]; // sea ‘\0’ que indica el final de la cadena

Página 12 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

ESTRUCTURA REPETITIVA while

TOPOLOGÍA:
while(Condición)
{
//Acciones a ejecutar
}
USO: Se utiliza en casos donde no se conoce la cantidad de veces que se repetirá el ciclo. El ciclo se
repite solo si se cumple la condición.

EJEMPLO 1: Encender y apagar un diodo led cada segundo indefinidamente.

while (1) // 1 siempre es TRUE, por lo tanto siempre se repite

{ // vea ejemplo 2 de ESTRUCTURA REPETITIVA for
LED = 1- LED; // si LED es 1 cambia a 0, si es 0 cambia a 1
__delay_ms(1000); // retardo de 1 segundo
}

EJEMPLO 2: Encender y apagar un diodo led cada segundo indefinidamente hasta que se toque
un pulsador ‘PULL’.

while (!PUL) // !PUL niega la condición del pulsador. PUL normalmente

{ // es 0 y negado es 1, o sea que la condición es cierta y el
LED = 1- LED; // ciclo se repite, pero cuando se presiona PUL es 1 y
__delay_ms(1000); // negado es 0; por tanto aborta el ciclo

Otra forma es implementar la instrucción break cuando se accione PULL

while (1) // el ciclo es infinito

{
if (PUL) // PUL es 1si se acciona el pulsador
break; // aborta el ciclo
LED = 1- LED; // si LED es 1 cambia a 0, si es 0 cambia a 1
__delay_ms(1000); // retardo de 1 segundo

EJEMPLO 3: Implementar un anti-rebote por software para el pulsador ‘PULL’.

if (PUL) // si se acciona el pulsador PUL

while (PUL) // se mantiene en el ciclo hasta que se desactive
{continue;} // hace nada mientras se ejecuta el ciclo

Página 13 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

EJEMPLO 4: Chequear si se activan los pulsadores INC y DEC para incrementar o decrementar la
variable MENU. Aborte el ciclo en caso que el pulsador OK se active.

while(!OK)
{
if (INC) MENU++; // si se activa INC se incrementa MENU
if (DEC) MENU--; // si se activa DEC se decrementa MENU
}

EJEMPLO 5: Diseñar el equivalente a la estructura del ciclo for(I=0;I<10;I++) usando ciclo while.
Para diseñar el equivalente es necesario crear la variable “I” para mantener la condición e
inicializarla antes de entrar al ciclo.

unsigned char I=0; // se inicializa la variable en 0

while(I<10) // se establece la condición del ciclo
{
I++; // se incrementa la variable
}

EJERCICIOS PROPUESTOS DE ESTRUCTURAS CONDICIONALES

1. Diseñe un programa para un microcontrolador PIC12F510 que use el cristal interno a 4MHz. Se
desea configurar todos los pines de salida excepto GP3 (consulte el datasheets para comprender por
qué). Se desea encender y apagar un diodo led color amarillo conectado a GP0 cada segundo.

2. Sin usar condicionales, diseñe un programa para un microcontrolador PIC12F510 que use el cristal
interno a 4MHz, configurando todos los pines de salida excepto GP3 (consulte el datasheets para
comprender por qué). Se desea:
a. Encender y apagar un diodo led color amarillo conectado a GP0 cada segundo.
b. Encender y apagar un diod led color rojo conectado a GP1 cada medio segundo.

3. Usando condicionales, diseñe un programa para un microcontrolador PIC12F510 que use el cristal
interno a 4MHz, configurando todos los pines de salida excepto GP3 (consulte el datasheets para
comprender por qué). Se desea:
a. Encender y apagar un diodo led color amarillo conectado a GP0 cada segundo.
b. Encender y apagar un diod led color rojo conectado a GP1 cada medio segundo.

4. Se dispone de un PIC16F84A con un cristal externo

de 8MHz que tiene 4 pulsadores conectados al
puerto A y 4 diodos led de colores diferentes
conectados al puerto B como se muestra en la figura
adjunta. Se debe diseñar un programa que se
enciendan el diodo led correspondiente a cada
pulsador, o sea, que se encienda VERDE cuando se
presione P1 y cuando se deje de presionar se
apague el led. Así para todos los pulsadores.

Página 14 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

5. En base al diseño anterior, se desea hacer un programa que encienda todos los diodos led cuando se
presionen por lo menos dos pulsadores (no importa cuáles sean) y se apaguen cuando se dejen de
presionar, o sea, los diodos se encienden cuando se presiona P1 y P2, o P1 y P3, o P1 y P4, y así con
todas las demás combinaciones.

6. En base al diagrama eléctrico del ejercicio 4, se desea que usted diseñe un programa que encienda
indefinidamente todos los diodos led cuando se presione P1 y P3, pero se apaguen indefinidamente
cuando se presione P2 y P4.

7. En base al diagrama eléctrico del ejercicio 4, se desea que usted diseñe un programa que:
 Encienda el led verde cuando se presione P1 o P2.
 Encienda el led rojo cuando se presione P1 o P3.
 Encienda el led amarillo cuando se presione P2 o P4.
 Encienda el led azul cuando se presione P3 o P4.
 Cuando se dejan de presionar los pulsadores se apagan los leds encendidos.

8. En base al diagrama eléctrico del ejercicio 4, se desea que usted diseñe un programa que encienda el
diodo verde cuando se presione P1 y se apague cuando se vuelva a presionar, emulando un flip flop
tipo T.

9. En base al diagrama eléctrico del ejercicio 4, se desea que usted diseñe un programa que encienda
los diodos consecutivamente cuando se presiona el pulsador P3, o sea, se enciende el diodo verde si
se presiona P3 una vez, pero enciende el diodo rojo si se presiona nuevamente, y así con todos los
diodos restantes. Cuando llega al final se apagan todos los diodos para volver a comenzar con el
verde. Use la estructura de programación if.

10. En base al diagrama eléctrico del ejercicio 4, se desea que usted diseñe un programa que encienda
los diodos consecutivamente cuando se presiona el pulsador P3, o sea, se enciende el diodo verde si
se presiona P3 una vez, pero apaga el diodo verde y enciende el diodo rojo si se presiona
nuevamente (apaga uno antes de encender el próximo), y así con todos los diodos restantes. Cuando
llega al final se apagan todos los diodos para volver a comenzar con el verde. Use la estructura de
programación if.

11. En base al diagrama eléctrico del ejercicio 4, se desea que usted diseñe un programa que encienda
los diodos consecutivamente cuando se presiona el pulsador P3, o sea, se enciende el diodo verde si
se presiona P3 una vez, pero apaga el diodo verde y enciende el diodo rojo si se presiona
nuevamente, y así con todos los diodos restantes. Cuando llega al final vuelve a comenzar con el
verde. Use la estructura de programación switch.

12. Resuelva los ejemplos del material de apoyo y los ejercicios propuestos del tema de lógica
combinacional y mapas de Karnaugh mediante el uso de un PIC16F873A, un cristal de 8MHz,
capacitores de 22pF, pulsadores o interruptores simulando las condiciones de entrada y diodos led
simulando los dispositivos de salida. Use únicamente las estructuras condicionales if o switch
además del ciclo infinito.

Página 15 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

EJERCICIOS PROPUESTOS DE CICLOS REPETITIVOS

13. Se dispone de un PIC16F873A, un cristal de 8MHz, 2

capacitores de 22pF y otros dispositivos como se
muestra en el diagrama adjunto. Se requiere diseñar
un programa usando la estructura repetitiva “for”
que muestre en la barra gráfica conectada en el
puerto B el valor binario de un contador que
comience en cero y se incremente de uno en uno
hasta 50.

14. Según el diagrama eléctrico del ejercicio 13, se requiere diseñar un programa usando la estructura
repetitiva “for” que muestre en la barra gráfica conectada en el puerto B el valor binario de un
contador que comience en cien y se decremente de dos en dos hasta 50.

15. Según el diagrama eléctrico del ejercicio 13, se requiere diseñar un programa que encienda los
segmentos pares de la barra gráfica conectada en el puerto B si el valor de un contador que
comienza en 15 y termina en 30 es par, y que encienda los segmentos impares de la barra si el valor
del contador es impar.

16. Según el diagrama eléctrico del ejercicio 13, se requiere diseñar un programa que muestre en el
primer segmento de la barra gráfica conectada en el puerto B sólo el último bit del contador que
comienza en 1 y termina en 10 cada segundo.

17. Según el diagrama eléctrico del ejercicio 13, se requiere diseñar un programa que muestre en el
primer segmento de la barra gráfica conectada en el puerto B los últimos 4 bits que componen un
contador que comienza en 1 y termina en 10 cada segundo, comenzando de derecha a izquierda, o
sea, sí el contador es cinco (0b00000101 en binario) se debe encender el segmento un segundo (1),
apagarse un segundo(viene 0), encenderse un segundo (viene 1) y apagarse un segundo (0). Use un
ciclo “for” dentro de otro ciclo “for”: el ciclo más externo para controlar el contador y el ciclo más
interno para mostrar los bits.

18. Repita el ejercicio anterior pero mostrando todos los bits del contador de izquierda a derecha.
Sugerencia: use un ciclo “for” antes sólo para invertir una copia del contador y luego mostrarla.

19. Según el esquema eléctrico adjunto, se requiere diseñar

un programa a 4MHz que muestre cada segundo en la
pantalla 7 segmentos el valor de un contador decreciente
de 9 a 0. Note que el valor del contador binario se
transforma en código 7 segmentos mediante el 74LS48
(Cátodo Común). Repita el programa sin usar el 74LS48,
sino conectando el microcontrolador directamente al 7
segmentos y empleando la estructura condicional
“switch” para decodificar el valor del contador.

20. Repita el ejercicio anterior (sin el 74LS48) usando la estructura condicional switch dentro de un
ciclo for para visualizar letras, o sea, se muestra la letra “A” o “a” cuando el contador sea 0, “B” o “b”
cuando el contador sea 1 y así sucesivamente hasta 9.

Página 16 de 17
 Dr. Julio J. Mendoza H.
0412-5620807 [email protected]

21. Según el esquema eléctrico adjunto,

se requiere diseñar un programa a
4MHz que muestre cada segundo
en la pantalla 7 segmentos el valor
de un contador decreciente de 9 a
0. Note que el valor del contador
binario debe ser transformado
mediante la estructura condicional
“switch” para decodificar el valor
del contador en forma inversa para
finalmente ser enviado al registro
de corrimiento vía serial y que se
visualice. Se debe usar un
programa similar al empleado en el
ejercicio 17 (for anidados).

22. Rediseñe los programas anteriores para cambiar las estructuras “for” por “while”.

23. Se requiere visualizar en un display 7 segmentos el valor de un número equivalente al valor de una
tecla presionada (teclado telefónico). Use un PIC18F4550 y su cristal interno a 20MHz, y un display
7 segmentos ánodo común. El valor se debe mostrar sólo 3 segundos en el display.

Página 17 de 17