Programacion Pic Con C 5h2n4a

#use RS232(BAUD=9600,BITS=8,PARITY=N,XMIT=PIN_B1,RCV=PIN_B2) void main() { int i1=9; lcd_init(); //función de inicialización del LCD //Mostramos una cadena en la terminal printf("Esto es una cadena\r"); //Mostramos una cadena de texto junto con el valor de una variable //en la terminal. printf("El valor de la variable i1 es: %d",i1); //Mostramos el valor de la variable por el LCD printf (lcd_putc,"El valor de i1 es: %d",i1);

40

Programación PIC en C

}

Comentario: En este primer ejemplo vamos a ver el uso de la función printf utilizando diferentes parámetros. Como vamos a utilizar la librería que incluye el compilador para el manejo de un LCD tenemos que incluir la directiva:

#include

Declaramos una variable i1 de tipo entero que nos va a servir para mostrar su valor en la terminal y en un LCD. Cuando utilicemos la librería LCD.C y antes de utilizar cualquier otra función incluida en la librería tenemos que llamar a la siguiente función que sirve para inicializar el LCD.

lcd_init();

En la primera llamada a la función printf como parámetros solo incluimos una cadena de caracteres constante que termina en (\r), esa barra invertida junto con la r se le llama secuencia de escape y le está diciendo al compilador que al final de la cadena introduzca un retorno de carro (tecla enter). Las secuencias de escape se utilizan para representar caracteres o acciones especiales.

printf("Esto es una cadena\r");

En la tabla de abajo se muestran las secuencias de escape que tenemos disponibles para utilizar con la función printf:

\r

Retorno de carro

\t

Tabulador 41


\'

Comilla simple

\"

Comillas dobles

\\

Barra invertida

\?

Símbolo de interrogación

\0

Caracter nulo

\%

Símbolo Tanto por ciento

\b

Retroceder un caracter

Vamos con la segunda llamada a la función:

printf("El valor de la variable i1 es: %d",i1);

En este caso tampoco está definido el primer parámetro, por tanto, al igual que en la primera llamada a la función, los datos se enviaran por el puerto serie al pin que hayamos definido en la directiva #use RS232, en esta llamada vemos que tenemos la cadena de caracteres limitada por las comillas dobles y separado por una coma, como tercer parámetro el nombre de la variable i1 que habíamos declarado previamente. En la cadena de caracteres vemos que aparece el carácter de % seguido de la letra d, ese es un carácter especial para la función y lo que le indica a la función es que en esa posición muestre el valor de la variable i1, la d le indica a la función que represente ese valor en formato de número entero. Podemos representar el valor de la variable en diferentes formatos según se muestra en la tabla de abajo:

c

Caracter

s

Cadena ó caracter

u

Entero sin signo

d

Entero con signo

Lu Entero largo sin signo Ld Entero largo con signo x

Entero Hexadecimal (minúsculas)

X

Entero Hexadecimal (mayúsculas)

Lx Entero largo Hexadecimal (minúsculas) LX Entero largo Hexadecimal (mayúsculas) f

Número real en coma flotante con truncado 42


g

Número real en coma flotante con redondeo

e

Número real en formato exponencial

w

Entero sin signo con decimales insertados. Especifica dos números para n. La 1ª cifra indica el total y la 2ª el número de decimales

Si quisiésemos mostrar el valor de más de una variable lo haríamos de la siguiente forma:

printf("El valor i1 es: %d el de i2: %d y el de i3: %d",i1,i2,i3);

Vamos con la última llamada a la función del 1º ejemplo:

printf (lcd_putc,"El valor de i1 es: %d",i1);

En esta llamada hemos incluido el primer parámetro y hemos puesto el nombre de la función lcd_putc, está función está definida en la librería LCD.C que trae el compilador para ayuda del manejo de los dispositivos LCD y que hemos incluido en nuestro programa por medio de la directiva #include , vemos que la librería está encerrada entre los símbolos de <> esto le indica al compilador que busque la librería en el directorio en que se instalo el compilador, si copiáramos esa librería en otro directorio tendríamos que indicarle la ruta completa, pero esta vez encerrada entre comillas dobles.

Ejemplo:

#include “C:\Ejemplos de C\lcd.c”

Pues bien ahora la función printf no enviará los datos al puerto serie, sino a la función lcd_puct que será la encargada de enviárselos al LCD, esta función por defecto envía los datos al puerto D del PIC, pero accediendo a la librería se puede modificar el puerto fácilmente. 43


Aquí tenéis un video demostrativo del ejemplo:

Ver vídeo

2º Ejemplo

Salida del programa:

44


Comentario del programa: El especificador de formato %x indica al sistema que escriba en hexadecimal (base 16) el valor sustituido. El ejemplo también escribe el carácter 'A', apoyándose en cuatro formas distintas de representaciones iníciales. En todos los casos se almacenará el mismo valor numérico, pero son diferentes las representaciones usadas. El carácter (A) sale en la terminal en una línea diferente cada vez que se imprime, eso es debido a la secuencia de escape (\r) utilizada. Observar que el ejemplo se ha hecho sobre el PIC 16f84 que no dispone de una USART hardware para la comunicación serie , pero sin embargo el programa se ha ejecutado correctamente, eso es debido a que la comunicación serie se ha establecido por software por medio de las librerías implementadas en el compilador PCW. Vamos a continuar con las funciones disponibles en CCS para la entrada y salida de datos a través del puerto serie RS-232. Hasta ahora solo hemos visto que con la función printf(), podemos enviar datos formateados a través del pin que hayamos seleccionado en la directiva: #use RS232(BAUD=9600,BITS=8,PARITY=N,XMIT=PIN_D1,RCV=PIN_D2)

En este caso los datos saldrán por el pin RD1 del PIC. Pero ¿de que funciones disponemos para recibir datos desde fuera hacia nuestro PIC?. El que haya programado 45


en C echará de menos la función scanf() definida en la librería stdio.h y perteneciente al estándar ANSI C. Pero desgraciadamente esa función tampoco está disponible en CCS. Pero tampoco hay por qué preocuparse mucho, porque disponemos de otras. En este caso vamos a ver las funciones: getc(), getch() y getchar(). Las tres hacen lo mismo por lo que podemos usarlas indistintamente.

Estas funciones esperan un carácter por la patilla del PIC que hayamos definido en la directiva #use RS232 con el parámetro RCV. En el caso del ejemplo de arriba, los datos serán recibidos por el pin RD2 del PIC.

Pues vamos a ver nuestro primer ejemplo acerca del uso de estas funciones:

Comentario: El ejemplo lo que hace es mostrar el valor de la tecla que pulsemos en el teclado y su equivalente en código ASCII

Vamos a explicar su funcionamiento paso a paso:

Primeramente, como siempre, incluimos por medio de la directiva #include el archivo de cabecera del PIC que vamos a utilizar, en este caso el PIC16F877. 46


Por medio de #use delay le decimos al compilador la frecuencia de reloj que vamos a utilizar en nuestro circuito. Configuramos los parámetro de la directiva #use RS232, fijaros que XMIT=PIN_D0 y que RCV=PIN_D1. Con lo cual los datos saldrán del PIC por el pin RD0 y entrarán por el pin RD1. Dentro de la función principal main(), escribimos lo que queremos que haga nuestro programa. Las instrucciones siempre empezarán a ejecutarse una a una a partir de esta función y de arriba hacia abajo. Lo primero que hacemos es declarar una variable de tipo char donde almacenaremos el valor de la tecla que pulsemos en el teclado. Después se nos mostrará un mensaje en la terminal invitándonos a que introduzcamos un carácter. printf("Introduzca un caracter :\r");

Después se ejecutará la sentencia: ch=getch()

Que esperará hasta que pulsemos una tecla y almacenará su valor en la variable ch. La siguiente instrucción: printf("El caracter %c tiene un valor ASCII decimal de %d.\r",ch,ch);

muestra el valor del carácter y su equivalente en código ASCII Después se repite el proceso dos veces más, pero esta vez utilizando las funciones getc() y getchar() Al utilizar solo la variable ch, el valor de la nueva tecla pulsada sobrescribirá el valor anterior de la variable.

La salida de nuestro programa será el siguiente:

47


Bien, hay que decir que el programa finalizará al llegar a la última sentencia incluida en la función main(). Para que el programa termine cuando nosotros queramos tenemos que incluir como mínimo un bucle y establecer una condición para que podamos salir de él, vamos a ver esto con otro ejemplo:

En este ejemplo se irán mostrando en la terminal las teclas que vayamos pulsando por el teclado hasta que pulsemos la tecla „n‟ momento en el cual finalizará el programa. 48


Los códigos fuentes de los ejemplos los tenéis aquí. Un par de funciones mas que se pueden utilizar en la entrada y salida de datos serie RS232 son las funciones gets() y puts().

gets(string): esta función lee los caracteres que se introducen por el teclado hasta que encuentra un retorno de carro (tecla Enter). El pin asignado para la lectura de los caracteres es el que hayamos configurado en RCV. En el ejemplo de abajo el pin RD5.

puts(string): esta función envía la cadena de texto contenida dentro de los paréntesis al pin que hayamos configurado en el parámetro XMIT de la directiva #use RS232, en el ejemplo de abajo el pin RD4. Una vez enviada la cadena añade un retorno de carro.

#use RS232(BAUD=9600, BITS=8, PARITY=N, XMIT=PIN_D4, RCV=PIN_D5)

Vamos a ver un ejemplo sencillo que utilice estas dos funciones:

49


Comentario En este ejemplo se ha declarado un tipo de dato que todavía no hemos visto, un array de caracteres:

char nombre[9];

Aunque veremos los tipos de datos compuestos más adelante, podemos adelantar que un array es un conjunto de variable del mismo tipo de datos. Cada una de esas variables se coloca de forma consecutiva en la memoria RAM del PIC y se les llama elementos del array. Los elementos del array se enumeran empezando por el 0, (es una característica del lenguaje C). En el ejemplo de arriba se ha declarado un array de caracteres (tipo char) y el número máximo de elementos que podemos almacenar en el es de 9. Sus elementos estarán numerados del 0 al 8. Y podemos acceder a ellos de la siguiente forma:

valor = nombre[0];

50


…….. = ……..[.];

valor = nombre[8];

El ejemplo lo único que hace es enviar un mensaje a la terminal diciéndonos que introduzcamos nuestro nombre (puede ser también una o lo que queramos). Cuando introduzcamos el nombre y pulsemos la tecla Enter, la cadena de caracteres será guardada en el array que hemos declarado previamente y luego con la primera función prinf() mostramos el valor de la cadena de texto guardada en el array, con la segunda función prinf() mostramos el tercer carácter del nombre introducido (nombre[2]). Este será la salida de nuestro programa:

Si intentamos introducir una cadena más larga, el valor se mostrará en la terminal pero truncado.

Por ejemplo si intentamos introducir la cadena:

51


“Microcontroladores PIC”

La terminal nos mostrará:

Microcont

Como he dicho antes los elementos del array se almacenan en posiciones consecutivas de la memoria RAM del PIC. Esto lo gestiona automáticamente el compilador, lo mismo que cuando haces un programa en C ó en otro lenguaje de alto nivel para un PC de escritorio el programador no está preocupado de en qué posición de la memoria RAM se almacenarán las variables que declara. Pero si a pesar de ello quieres saberlo haces lo siguiente:

Después de compilar el ejemplo, te vas al menú compile –> Symbol Map y nos aparecerá la ventana de abajo:

Donde vemos las posiciones de memoria donde se han mapeado nuestras variables. Como vemos nuestro array ha ocupado las posiciones de memoria de la 0x21 a la 0x29 de los registros GPR del PIC (en total 9 bytes), ya que los elementos que componen el Array son de tipo char que son de un byte (8 bits) cada uno. 52


Si queremos ver los valores que va tomando cada uno de los elementos del Array en tiempo de ejecución. Lo podemos hacer por medio de la ventana Watch Windows en Proteus. Si no te acuerdas de cómo se hace míralo aquí

Y obtendremos lo siguiente:

Consideraciones: En C existe el concepto de memoria dinámica. La memoria dinámica es aquella que se puede reservar y liberar en tiempo de ejecución, es decir, durante la ejecución del programa se liberará y se asignará memoria para optimizar los recursos de la U, para ello se dispone de funciones como malloc() y free(). El compilador CCS también ite este tipo de funciones, para utilizarlas debemos de incluir el archivo de cabecera stdlibm.h, ya veremos un ejemplo sobre la asignación de memoria dinámica, si no utilizamos estas funciones la reserva de memoria es estática, es decir, si declaramos un array de nueve elementos el compilador le reservará memoria contigua a dicho array al compilar el programa en los registros de propósito general (GPR). Esa memoria se reserva cuando el PIC empieza a ejecutar su programa y permanece reservada hasta que desconectamos el PIC. Con todo esto quiero decir que tenemos que tener siempre claro de la memoria RAM de que disponemos, según el modelo de microcontrolador que utilicemos en nuestro proyecto, si no lo sabes consulta el data sheet del PIC que estés utilizando. Por ejemplo si en el PIC del ejemplo que hemos hecho (16f877) en vez 53


de un array de 9 elementos declaramos uno de 100 elementos el compilador nos mostrará el siguiente error al compilar:

Y como ya he dicho en alguna ocasión, utiliza el tipo de datos más pequeño posible, en el ejemplo que he puesto he declarado un array de nueve elementos, para introducir el nombre “Antonio” que tiene seis caracteres, con lo cual estoy desperdiciando dos bytes de memoria RAM, eso en un ordenador de escritorio es insignificante pero en un microcontrolador si que es importante y puede que nos quedemos sin memoria suficiente para declarar todas las variables de nuestro programa.

El código del ejemplo lo tenéis aquí

Aunque existen algunas funciones más para la entrada y salida de datos serie, las que llevamos vistas hasta ahora son las más importantes, así que el próximo día empezaremos con los operadores, indispensables para hacer operaciones con los datos que introduzcamos en nuestro programa. l lenguaje C dispone de una gran cantidad de operadores que nos sirven para operar con los datos dentro de nuestros programas, se pueden clasificar en varios apartados: aritméticos, relacionales, de asignación, de manejo de un solo bit, etc. Pero lo importante no es saber a qué grupo pertenece cada operador, sino en conocer la operación que se puede realizar con cada uno de ellos. Vamos a ver los operadores que nos permite utilizar nuestro compilador CCS.

Operadores Aritméticos: permiten la realización de operaciones matemáticas en nuestros programas. 54


Operador

Descripción

+

Suma

-

Resta

*

Multiplicación

/

División

%

Módulo (Resto de una división entera)

++

Incrementa en uno el valor del operando

--

Decrementa en uno el valor del operando

Operadores relacionales: compara dos operandos y devuelve 1 (verdadero) ó 0 (falso) según el resultado de la expresión. Se utilizan principalmente para elaborar condiciones en las sentencias condicionales e iterativas que se verán más adelante.

Operador

Descripción

<

Menor que

>

Mayor que

<=

Menor o igual que

>=

Mayor o igual que

==

Igual a

¡=

Distinto de

Operadores de asignación: permiten asignar valores a las variables. Tenemos las siguientes.

Operador Descripción += Asignación de suma. x+=y es lo mismo que x=x+y -=

Asignación de resta. x-=y es lo mismo que x=x-y

*=

Asignación de multiplicación. x*=y es lo mismo que x=x*y

/=

Asignación de división. x/=y es lo mismo que x=x/y

55


%=

Asignación de resto de división. x%=y es lo mismo que x=x%y

<<=

Asignación de desplazamiento a la izquierda. x<<=y es lo mismo que x=x<

>>=

Asignación de desplazamiento a la derecha. x>>=y es lo mismo que x=x>>y

&=

Asignación de AND de bits. x&=y es lo mismo que x=x&y

|=

Asignación de OR de bits. x|=y es lo mismo que x=x|y

^=

Asignación de OR exclusivo de bits (XOR). x^=y es lo mismo que x=x^y

Operadores Lógicos: Al igual que los operadores relacionales, éstos devuelven 1 (verdadero), 0 (falso) tras la evaluación de sus operandos. La tabla siguiente ilustra estos operadores.

Operador !

Descripción NO lógico

&&

Y lógico

||

O lógico

Operadores de manejo de bits: Estos operadores permiten actuar sobre los operandos para modificar un solo bit, los operandos sólo pueden ser de tipo entero (incluyendo el tipo char).

Operador

Descripción

~

Negación de bits (complemento a 1)

&

Y de bits (AND)

|

O de bits (OR)

^

O exclusivo de bits (XOR)

>>

Desplazamiento a la derecha

<<

Desplazamiento a la izquierda

56


Operadores para manejar punteros: En el lenguaje C está muy difundido el uso de punteros, este compilador permite su uso y los operadores que utiliza para ello son los siguientes:

Operador & Operador de dirección

Descripción

*

Operador de inderección

->

Acceder a los de una estructura por medio de punteros

Los que se inician en el mundo de la programación suelen encontrar complicado el emplear punteros en sus programas pero, una vez que se entiende el concepto se simplifica y optimiza mucho nuestro código. Ya dijimos que el PIC dispone de unos registros de propósito general (GPR) que el programador utiliza para almacenar allí sus variables y poder utilizarlas a lo largo del programa, pues bien un puntero es otra variable a la cual se le asigna la dirección del registro ó memoria de otra variable.

La forma de utilizar los punteros lo veremos en profundidad más adelante, pero aquí tienes un pequeño ejemplo de cómo utilizarlos.

Ejemplo:

int y,z; //declaración de las variables x e y de tipo entero: int *x; //declaración de la variable puntero x que guardará la dirección de memoria de una variable de tipo entero. x=&y; // a través del operador de dirección (&) le asigno al puntero x la dirección de memoria donde está guardada la variable y. z=*x; //a través del operador de inderección (*) le asignamos a z el valor de la variable cuya dirección está almacenada en la variable puntero x.

57


Nota: como vemos los símbolos de dirección (&) e inderección (*) son los mismos que el AND en el manejo de bits (&) y el operador aritmético de multiplicación, el compilador los diferencia según los operandos que le preceden.

Precedencia de los operadores:

Expresiones en orden descendente de precedencia (expr) !expr

~expr

++expr

expr++

--expr

(type)expr

*expr

&value

sizeof(type)

expr*expr

expr/expr

expr%expr

expr+expr

expr-expr

expr<<expr

expr>>expr

expr<expr

expr<=expr

expr --

expr>expr expr>=expr

expr = = expr expr!=expr expr&expr expr^expr expr | expr expr&& expr expr || expr expr ? expr: expr value = expr

value+=expr value-=expr

value*=expr

value/=expr

value%=expr

value>>=expr value<<=expr value&=expr value^=expr

value|=expr

expr,expr

Las operaciones con mayor precedencia se realizan antes que las de menor precedencia. Si en una operación encontramos signos del mismo nivel de precedencia, dicha operación se realiza de izquierda a derecha. Ejemplo: a*b+c/d-e Las operaciones se realizarán en el siguiente orden: 58


1. 2. 3. 4.

a*b resultado = x c/d resultado = y x+y resultado = z z-e

Nota: Es aconsejable el uso de paréntesis para evitar errores en la precedencia de operadores, además el código fuente queda más legible. Ejemplo: a*(b+c)+d En este caso el orden en realizarse las operaciones será el siguiente: 1. b+c resultado = x 2. a*x resultado = y 3. y+d sizeof(type)--> nos da el tamaño en bytes del tipo de dato ó variable que le pongamos entre los paréntesis. Para conocer bien los resultados que se obtienen al utilizar cada uno de los operadores, lo mejor es practicar con ellos. Vamos a ver un ejemplo donde se muestra el uso de algunos de ellos:

59


Comentario del programa: En este ejemplo introducimos unos valores por el teclado del ordenador y se los enviamos al pic via serie por el dispositivo RS-232, luego realizaremos diferentes operaciones con ellos y mostraremos el resultado en la Terminal, pero hay que tener en cuenta que que esos valores que introducimos por el teclado son caracteres y por tanto no se los podemos asignar directamente a una variable de tipo entero para operar con ellos, primero tenemos que convertirlos. CSS nos proporciona las siguientes funciones para ello:

60


- atoi(cadena) --> devuelve un valor entero de 8 bits de tamaño. - atol(cadena) --> devuelve un valor entero de 16 bits - atoi32(cadena) --> devuelve un valor entero de 32 bits

Para saber el rango de valores isible por cada función repasa los tipos de datos

Estas funciones están definidas en el fichero de cabecera stdlib.h, por tanto no hay que olvidarse de incluirlo previamente por medio de la directiva: #include <stdlib.h>.

Fijaros en la instrucción de la línea 31 que nos da el tamaño de la variable y:

printf("El tama\xa4o de y es: %d bytes\r",sizeof(y));

\xa4 --> es la secuencia de escape para representar la letra ñ. Esto es porque el compilador no reconoce los caracteres en castellano.

Tabla equivalente de caracteres en castellano:

á

\xa0

é

\x82

í

\xa1

ó

\xa2

ú

\xa3

Á \xb5 É \x90 Í

\xd6 61


Ó \xe0 Ú \xe9 ñ

\xa4

Ñ \xa5 ¿

\xa8

La salida del programa para los valores de x=50 e y=6 es la siguiente:

El código fuente y el DSN de proteus lo tenéis aqui.

Una precaución que tenemos que tener en cuenta es que si utilizamos valores numéricos grandes y un PIC con poca memoria RAM, pronto la agotaremos. Esto solo es un ejemplo teórico del uso de operadores aritméticos, aplicaciones prácticas puede tener muchas, depende de lo que quieras hacer.

Un ejemplo sencillo pero práctico, lo tienes aquí. SENTENCIAS REPETITIVAS:

62


Son aquellas que ejecutan un bloque de sentencias mientras se cumpla una expresión lógica. Este bloque de sentencias que se ejecuta repetidas veces, se denomina bucle, y cada ejecución se denomina iteración.

De las diferentes sentencias repetitivas que hay vamos a empezar con while.

La sentencia while permite la ejecución de un bloque de sentencias si se evalúa como verdadera una expresión lógica. La expresión lógica aparece al principio del bloque de sentencias. En la figura de abajo se muestra el Pseudocódigo, el diagrama de flujo y la sintaxis de la sentencia while.

63


El Pseudocódigo es una forma informal de representar la secuencia del programa, sin tener en cuenta la sintaxis particular del lenguaje en que vayamos a programar y el diagrama de flujo es una representación gráfica del Pseudocódigo.

Cuando vayamos a crear un programa el dibujar previamente un diagrama de flujo ó el Pseudocódigo de la secuencia de nuestro programa puede ayudarnos en la tarea de programación, pero en ningún caso es un paso obligatorio.

El bloque delimitado por las llaves puede reducirse a una sentencia, y en este caso se suprimen las llaves.

La expresión lógica debe estar delimitada por paréntesis.

Cuando el programa llega a una sentencia while, sigue los siguientes pasos. Evalúa la expresión. Si es falsa, continua la ejecución tras el bloque de sentencias. Si es verdadera entra en el bloque de sentencias asociado al while. Ejecuta dicho bloque de sentencias, evaluando de nuevo la expresión y actuando en consecuencia. Si la primera evaluación resulta falsa, el bloque de sentencias no se ejecuta nunca.

Si la expresión es siempre cierta el bucle es infinito.

Vamos con el primer ejemplo:

64


Comentario El ejemplo lo que hace es mostrar en la terminal la tabla de multiplicar del número cuatro, utilizando un bucle while. Para ello necesitamos declarar una variable auxiliar de tipo entero llamada i1, inicializada con el valor de 1, en cada iteración se comprueba el valor de la variable auxiliar, mientras el valor de i1 sea <=10 la evaluación será verdadera y se ejecutarán las instrucciones que hay dentro del bloque while, dentro de ese bloque tenemos que incrementar el valor de i1, de esta manera nos aseguramos en algún momento la salida del bucle, cuando i1 llegue a 11 la condición será falsa y la secuencia del programa saltará a la línea 19 finalizando el programa.

La salida del programa será el siguiente:

65


Si queremos que el programa este siempre ejecutándose (lo normal en un programa para Microcontroladores), hay que colocar un bucle infinito, mira el siguiente ejemplo:

66


Comentario true es una constante booleana que equivale a 1 ó verdadero. Por tanto la evaluación del bucle siempre será cierta y no habrá manera del salir de él. El programa estará siempre esperando a que pulses una tecla y mostrará el valor de la tecla pulsada en la terminal. Bucle for() En el ejemplo de la tabla de multiplicar utilizamos el bucle while para obtener los diez valores de la tabla, y si recordáis necesitábamos una variable de control que teníamos que inicializar antes de entrar en el bucle, comprobar el valor de la variable para la continuación en el bucle y la modificación posterior de la variable de control para poder salir del bucle en un momento determinado.

Pues bien, casi siempre que se hace algo, C proporciona frecuentemente un modo más compacto de hacer lo mismo.

El bucle for permite indicar estos tres elementos en un solo lugar, al principio del bucle, facilitando así la obtención de un código compacto, pero legible. Veamos cual es su sintaxis:

67


En un bucle for, el paréntesis que acompaña a la palabra reservada for generalmente contiene tres expresiones: Expresión 1; inicializa la variable ó variables de control del bucle. Expresión 2; representa la condición de continuación en el bucle. Expresión 3; modifica el valor de las variables de control en cada iteración del bucle. Los puntos y comas que separan cada expresión son obligatorios.

Vamos a ver un ejemplo donde se muestran las diferentes posibilidades de que disponemos cuando utilicemos el bucle for:

68


Comentario 1º bucle for:

indice=1, inicializa a la variable de control del bucle. La segunda expresión, indice<=VAL_MAX, representa la condición de continuación. Por último, la tercera expresión, indice++, utiliza el operador de incremento para modificar a la variable de control en cada iteración del bucle. 69


Los pasos que sigue la sentencia for son los siguientes:

1. indice es la variable de control. Se inicializa a 1 2. se testea la condición de expresión_2. 3. se ejecutan las sentencias 4. la variable de control indice se incrementa en uno 5. si se cumple que indice<=VAL_MAX va al paso 3. Si no va al paso 6. 6. Finalizará la ejecución cuando indice=20

2º bucle for

Bucle for con varias variables de control, las variables tienen que ir separadas por comas. En este caso tenemos las variables x e y, aunque podemos poner todas las que queramos, ambas variables son inicializadas dentro de la sentencia for.

3º bucle for

Cuando el bucle for se escribe sin cuerpo sirve por ejemplo para generar retardos, esta posibilidad la utilizaremos poco con este compilador ya que incluye funciones específicas de retardo.

4º bucle for

El bucle for permite no incluir las expresiones 1 y 3, aunque los puntos y comas son obligatorios ponerlos. En este caso se asemeja mucho a un bucle while.

70


5º bucle for

Se puede crear un bucle infinito por medio de la expresión for(;;). Podemos salir de un bucle infinito por medio de la sentencia break, cuando se encuentra en cualquier lugar dentro del cuerpo de un bucle da lugar a la terminación inmediata de este, en el caso del ejemplo saldremos del bucle cuando pulsemos la letra „v‟. Las sentencias de salto las veremos más adelante.

La salida del programa será la siguiente:

El código fuente lo tenéis aquí.

Como veis el lenguaje C posee mucha flexibilidad y se puede hacer una misma cosa de varias formas. Según el caso será más cómodo y legible utilizar una sentencia que otra.

71


Como ejercicio podéis hacer la tabla de multiplicar de un número utilizando el bucle for. Bucle do-while() A diferencia de los bucles for y while, que analizan la condición del bucle al principio del mismo, el bucle do-while analiza la condición al final del bucle. Esto significa que el bucle do-while siempre se ejecuta al menos una vez. La forma general del bucle do-while es la que se muestra en la figura de abajo:

Vamos a ver un ejemplo:

72


Comentario Este ejemplo pide un valor entre 1 y 10, ejecutándose repetidas veces hasta que se introduce un valor entre ambos límites. Por último el programa visualiza el valor leído.

Este bucle se ejecutará como mínimo una vez porque el programa no sabe cuál es la condición de continuación hasta que se encuentra el while del final del cuerpo del bucle. Si la condición sigue siendo cierta (es decir, si el valor leído está fuera del intervalo deseado), el programa regresa al principio del bucle do-while y lo ejecuta de nuevo.

Fijaros en la orden if que aparece dentro del cuerpo del bucle. Esto se permite porque las estructuras de control se pueden anidar unas dentro de otras.

73


RECUERDA: En el bucle while la comprobación de la condición de control del bucle se encuentra al principio, por lo que dicho bucle puede no ejecutarse nunca; la comprobación en el bucle do-while está al final del bucle, por lo que al menos se ejecutará una vez.

El código fuente lo tenéis aquí. If Vamos a empezar las sentencias condicionales, con la más simple de todas, la sentencia if. Si se evalúa como cierta la expresión que hay entre paréntesis al principio de la sentencia if se ejecuta el bloque de sentencias contenido entre las llaves y si se evalúa como falsa la condición, el programa se salta ese bloque de instrucciones. En la figura de abajo tenéis la sintaxis de esta sentencia.

74


Si sólo hay una sentencia se pueden suprimir las llaves, ejemplo:

if (x=1) printf(“Sin llaves solo una sentencia asociada al if”);

Como ejemplo de sentencias if tenéis el decodificador de binario a decimal. Sentencia If…Else Cuando el programa llega a una sentencia condicional del tipo If …Else, primero se evalúa una expresión; si se cumple (es cierta) se ejecuta un bloque de sentencias y si es falsa se ejecuta otro bloque.

En la figura de abajo se muestra la sintaxis de esta sentencia condicional.

75


Ejemplo:

Comentario Este ejemplo visualiza en el display de cátodo común, conectado a la puerta B del PIC, el “0” si el interruptor conectado a RA0 está abierto y “1” si está cerrado, para ello utiliza la sentencia if-else, dentro de un bucle infinito para que el programa esté siempre chequeando el estado de la patilla RA0.

En este ejemplo hemos incluido una directiva nueva #use fast_io(puerto). Esta directiva se utiliza para optimizar el código generado por el compilador cuando se utilizan funciones de manejo de entrada y salida como “input(pin)” definidas ya en CCS.

76


Si no se incluye esta directiva el compilador tomará por defecto la directiva #use standard_io(A), que hará que cada vez que se utilicen estas funciones se reprograme el pin correspondiente como entrada ó salida, lo que hará que el código ASM generado tras la compilación sea mayor.

Podemos comprobar esto si después de compilar nuestro ejemplo, dentro del IDE de CCS seleccionamos Compile--> C/ASM List

Como se ve en la figura la memoria de programa (ROM) ocupa 21 palabras.

Ahora se pueden hacer las siguientes pruebas, la primera poner la directiva #use standard_io(A), y la segunda simplemente quitar la directiva #use fast_io(A) y no poner nada, según se muestra en la figura de abajo:

77


Volvemos a compilar y en ambos casos obtendremos lo siguiente:

78


En ambos casos la memoria ROM utilizada es de 24 palabras, tres más que cuando utilizábamos la directiva #use fast_io(A).

Otras funciones para el manejo de bits de los puertos de entrada y salida que vienen definidas en CCS y que dependen de la directiva #use*_io() son:

output_bit(Nombre_pin,valor) --> coloca el pin indicado a 0 ó 1. output_high(Nombre_pin) --> coloca el pin indicado a 1. output_low(Nombre_pin) --> coloca el pin indicado a 0

Fijaros que no he utilizado la directiva #use fast_io(B) para el puerto B, ya que no se utilizan funciones del compilador para el manejo de los bits de salida. En este caso el puerto B del PIC se controla mapeando la dirección de memoria del puerto B como una variable más en la RAM del PIC, por medio del identificador port_b.

79


Circuito del ejemplo:

El código del ejemplo y el circuito en Proteus lo tenéis aquí Sentencia switch La sentencia switch se compone de las siguientes palabras clave: switch, case, default y break.

Lo que hace está sentencia es comparar sucesivamente el valor de una expresión (dicha expresión tan solo puede ser de tipo entero o de tipo carácter) con una lista de constantes enteras o de caracteres. Cuando la expresión coincide con la constante, ejecuta las sentencias asociadas a ésta.

La estructura de la sentencia switch es la siguiente:

80


La sentencia break hace que el programa salte a la línea de código siguiente a la sentencia switch. Si se omite se ejecutará el resto de casos case hasta encontrar el próximo break.

La sentencia default se ejecuta cuando no ha habido ninguna coincidencia. La parte default es opcional y, si no aparece, no se lleva a cabo ninguna acción al fallar todas las pruebas y el programa seguirá a partir de la llave que cierra la sentencia switch

Consideraciones a la hora de usar esta sentencia: 81


En una sentencia switch No puede haber dos sentencias case con el mismo valor de constante. Una constante char se convierte automáticamente a sus valores enteros. Switch difiere del if en que switch solo puede comprobar la igualdad mientras que if puede evaluar expresiones relacionales o lógicas. Además cuando la comparación se basa en variables o se trabaja con expresiones que devuelven float deberemos usar el if-else. Hay que decir que la secuencia de sentencias en un case no es un bloque (no tiene porque ir entre llaves). Por lo tanto no podríamos definir una variable local en él. Mientras que la estructura swith global sí que es un bloque.

Vamos a ver un ejemplo para ver todo esto:

82


Comentario

En el ejemplo introducimos un carácter numérico, lo almacenamos en el array llamado cadena1 y por medio de la función atoi() lo convertimos a un valor entero y guardamos su valor en la variable de tipo entero num, no hay que olvidarse de incluir el archivo de cabecera “stdlib.h” necesaria para la función atoi().

Ahora introducimos valores para ver que obtenemos a la salida. Si introducimos un “1”, coincidirá con el valor de la constante asignada al primer case, por lo cual se ejecutan las dos primeras sentencias y el programa para de ejecutar sentencias porque se ha encontrado con un break, después ejecuta el último printf() por estar esta sentencia fuera de las llaves que delimitan a switch.

83


Fijaros en el segundo case, he omitido su break correspondiente a posta (el compilador no da error si se quita), para que veáis el resultado cuando se introduce un “2”:

Como veis en la figura de arriba se ejecutan las sentencias pertenecientes al segundo case, pero al no encontrar la sentencia break, ejecuta también la sentencia del tercer case. Esto hay que tenerlo en cuenta para tener claro que lo que hace salir de la sentencia switch es el break correspondiente a cada case. Si introducimos por ejemplo un “9” al no a ver coincidencia con el valor de ningún case, se ejecutará la sentencia perteneciente a default.

El código fuente del ejemplo lo tenéis aquí.

Un ejemplo un poco más práctico del uso de esta sentencia, lo tenéis aquí, gracias a QuijotescoXp, que ha hecho una mejora en el decodificador binario a decimal que en su día incluí en la sección de prácticas, os animo a que participes en el foro aportando mejoras ó ejemplos nuevos, de esta forma ayudas a que el curso vaya para adelante, si es que realmente os interesa.

84


www.aquihayapuntes.com

Tutorial creado por Biblioman. Versión 1.00 http://www.aquihayapuntes.com/programacion-pic-en-c.html Portado a PDF por Meta. http://electronica-pic.blogspot.com Cualquier sugerencia, duda o cualquier comentario, puedes realizarla en el foro aquí: http://www.aquihayapuntes.com/foro Puede haber futuras actualizaciones, mejoras y contenidos.

85

Programacion Pic Con C 5h2n4a

Overview 4q3b3c

More details 26j3b

Related Documents 171j1w

Programacion Pic Con C 5h2n4a

Programacion Con Ado.net C#.pdf 1p1y55

Microcontroladors Pic - Linguagem C 3j692q

Spwm Con Pic 6r705q

Reloj Digital Con Pic 1h5g6

Proyectos Con Pic 5o2d6r