DTO. INGENIERIA ELECTRÓNICA

1. DTO. INGENIERIA ELECTRÓNICA Compilador C para PICCCS C TEMA 6A

2. Compilador C para PIC • CCS PIC COMPILER • Un compilador convierte un lenguaje de alto nivel a instrucciones en código máquina. • Un “cross-compiler” es un compilador que funciona en un procesador (normalmente en PC) diferente al procesador objeto. Varios compiladores C tiene como procesador objetos los PICmicro tal es el caso de HiTECH, MicroChip y CCS. • Los programas son editados y compilados a instrucciones máquina en el PC. • El código máquina es cargado del PC al sistema PIC mediante el ICD2. • El código es ejecutado en el PIC y puede ser depurado (puntos de ruptura, paso a paso, etc) desde el PC. • Nota: Ver documentos anexos sobre CCS

3. Compilador C para PIC • CCS PIC COMPILER • Los elementos básicos de un programa en C • Directivas de preprocesado • Indican al compilador cómo debe generar el código máquina. • Programas • Bloques de programa. • Siempre debe incluirse una llamada main(). • Sentencias • Instrucciones que definen lo que hace el programa y la secuencia de ejecución del mismo. • Comentarios • Imprescindibles como documentación del código fuente.

4. Compilador C para PIC • VARIABLES • Una variable es un nombre asignado a una o varias posiciones de memoria RAM. • En C es necesario declarar todas las variables antes de poder utilizarlas, indicando el nombre asignado y el tipo de datos que en ella se van a almacenar (opcionalmente también el valor inicial asignado). • tipo nombre_variable [=valor]; p.e.:int i; • Los tipos de datos aceptados en C estándar son cinco: • char (carácter) int (entero) • float (coma flotante en 32 bits) double (coma flotante en 64 bits) • void (sin valor) • Las variables pueden ser locales o globales. Las variables locales sólo pueden ser usadas en la función en que se declaran, mientras que las variables globales son compartidas por todas las funciones del programa (deben declararse fuera de cualquier función y antes de ser utilizadas).

5. Compilador C para PIC • VARIABLES • El compilador de CCS acepta los siguiente tipos de variable. • Especificación Significado Tamaño Rango • char carácter 8 bits 0 a 255 (sin signo) • int entero 8 bits 0 a 255 (sin signo) • float coma flotante 32 bits 6 bits de precisión • double float doble precisión no soportado No para PCM • void sin valor nulo ninguno • int1 entero de 1 bit 1 bit 0 a 1 • int8 entero de 8 bits 8 bits 0 a 255 (sin signo) • int16 entero de 16 bits 16 bits 0 a 65535 (sin signo) • int32 entero de 32 bits 32 bits 0 a (232-1) • short entero de 1 bit 1 bit 0 a 1 • long entero de 16 bits 16 bits 0 a 65535 (sin signo) • Los tipos de variable short y long pueden tener detrás la palabra int sin efecto alguno.

6. Compilador C para PIC • VARIABLES • Todos los tipos de datos son por defecto sin signo (unsigned) salvo los de tipo float. • Para almacenar datos con signo, hay que introducir el modificador signed delante del tipo. El efecto que se consigue es el recogido en la siguiente tabla. • Especificación Significado Tamaño Rango • signed char carácter con signo 8 bits -128 a 127 • signed int16 entero con signo 16 bits -16384 a 16383 • signed long coma flotante 16 bits -32768 a 32767 • Los números negativos se codifican en complemento a 2. • Cuando se opera con distintos grupos de datos en una misma expresión, se aplican una serie de reglas para resolver las diferencias. En general se produce una “promoción” hacia los tipos de datos de mayor longitud presentes en la expresión.

7. Compilador C para PIC • FUNCIONES • Las funciones son los bloques constructivos fundamentales en C. Todas las sentencias deben encontrarse dentro de funciones. • Las funciones deben ser definidas antes de ser utilizadas. • Formato general de definición de una función: • tipo_dato_return nombre_func (tipo param1 , tipo param2 , … ) • { • cuerpo de la función (sentencias); • } • Las funciones pueden devolver un valor a la sentencia que las llama. El tipo de dato devuelto se indica mediante tipo_dato (char, int16, long). Si no se indica nada, se entiende que devuelve un entero. Si no devuelve nada, debe incluirse una especificación tipo void.

8. Compilador C para PIC • FUNCIONES • La manera que tiene una función para devolver un valor es mediante la sentencia return. • return (expresión); return expresión; • La expresión debe proporcionar el mismo tipo de dato que el especificado en la función. Si no debe devolver nada, se finaliza con return; • Cuando una función se encuentra con una sentencia return se vuelve a la rutina de llamada inmediatamente y las sentencias posteriores a return no se ejecutan. • Además de con las sentencia return, las funciones terminan su ejecución y vuelven al lugar desde donde se les llamó cuando alcanzan la llave de cierre de función } tras ejecutar la última sentencia de la misma.

9. Compilador C para PIC • FUNCIONES • Además de devolver valores, una función también puede recibir parámetros (denominados argumentos) según se indicó en su definición. • int suma (int a , int b) Parámetros formales • { • return (a+b); • } • main() • { • int c; • c = suma (10 , 23); Argumentos de llamada • } • Los argumentos se pueden pasar a las funciones por valor o por referencia. • La llamada por valor copia el argumento de llamada en el parámetro formal de la función (No modifica su valor en la función de partida). • La llamada por referencia usa la dirección de la variable que se pasa a la función (se consigue usando punteros o arrays).

10. Compilador C para PIC • OPERADORES • El lenguaje C define numerosos operadores mediante los cuales se construyen las expresiones (combinación de operadores y operandos). • De asignación • Aritméticos

11. Compilador C para PIC • OPERADORES • Relacionales • Lógicos • De bits

12. Compilador C para PIC • OPERADORES • In/decremento • Desplazamiento bit • Dirección/indirección • En lenguaje C “profesional” es muy frecuente usar abreviaturas. • Así, por ejemplo, es más habitual ver a += b; que a = a + b;

13. Compilador C para PIC • OPERADORES

14. Compilador C para PIC • DECLARACIONES

15. Compilador C para PIC • Sentencias de control de programa • Sentencia if • Se ejecuta una sentencia o bloque de código si la expresión que acompaña al if tiene un valor distinto a cero (verdadero). Si es cero (falso) continúa sin ejecutar la sentencia o bloque de sentencias. • if (expresión) • sentencia; { • sentencia 1; • sentencia 2; • ... • } • Sentencia if-else • Se evalúa una expresión y, si es cierta, se ejecuta el primer bloque de código (o sentencia 1). Si es falsa, se ejecuta el segundo. • if (expresión) • sentencia 1; (expresión) ? (sentencia 1) : (sentencia 2); • else • sentencia 2;

16. Compilador C para PIC • Sentencias de control de programa • Sentencia if-if/else If (P1 !=0) c=20; else c=0; If (a>b) { If (a>d) c = 15; else c=0; } If (a>b) { If (a>d) c = 15; } else c=0;

17. Compilador C para PIC • Sentencias de control de programa • Sentencia switch • Substituye a if-else cuando se realiza una selección múltiple que compara una expresión con una lista de constantes enteras o caracteres. Cuando se da una coincidencia, el cuerpo de sentencias asociadas a esa constante se ejecuta hasta que aparezca break. • switch (expresión) • { • case constante 1: • grupo 1 de sentencias; • break; • case constante 2: • grupo 2 de sentencias; • break; • ... • default: • grupo n de sentencias; • } break es opcional. Si no aparece se sigue con el case siguiente. No puede haber constantes iguales en dos case de la misma sentencia switch. default es opcional y el bloque asociado se ejecuta sólo si no hay ninguna coincidencia con las constantes especificadas.

18. Compilador C para PIC • Sentencias de control de programa • Sentencia switch Switch (k) { case 0: x=1; break; case 2: c=6; b=15; break; case 3: x=12; break; default: break; }

19. Compilador C para PIC • Sentencias de control de programa • Sentencia de bucle for • Se emplea para repetir una sentencia o bloque de sentencias. • for (inicialización ; condición ; incremento) • { • sentencia(s); • } • En la inicialización se le asigna un valor inicial a una variable que se emplea para el control de la repetición del bucle. • La condición se evalúa antes de ejecutar la sentencia. Si es cierta, se ejecuta el bucle. Si no, se sale del mismo. • El incremento establece cómo cambia la variable de control cada vez que se repite el bucle. • Es posible anidar bucles for para modificar dos o más variables de control.

20. Compilador C para PIC • Sentencias de control de programa • Sentencia de bucle for For (i=1;i<=100;i++) { delay_ms(33); px=?px; } For (y=1;i<=99;y=y+3) { delay_ms(33); px=y; }

21. Compilador C para PIC • Sentencias de control de programa • Sentencia de bucle while • La repetición se lleva a cabo mientras sea cierta una expresión. • while (expresión) • { • sentencia(s); • } • La expresión se evalúa antes de cualquier iteración. Si es falsa, ya no se ejecuta la sentencia o bloque de sentencias. • Sentencia de bucle do-while. • do • { • sentencia(s); • } • while (expresión) • Las sentencias se ejecutan antes de que se evalúe la expresión, por lo que el bucle se ejecuta siempre al menos una vez.

22. Compilador C para PIC • Sentencias de control de programa • Sentencia de bucle while-do/while while (x>0 && y++<5) { a=1; b=45; x=p1; } do { a=1; b=45; x=p1; } while (x>0 && y++>5);

23. Compilador C para PIC • Comentarios • Los comentarios se incluyen en el código fuente para explicar el sentido y la intención del código al que acompañan. Son ignorados por el compilador y no afectan a la longitud ni rapidez de ejecución del código final. • Un comentario se puede colocan en cualquier lugar del programa y pueden tener la longitud y el número de líneas que se quiera. • Hay dos formatos posibles para los comentarios. • Formato 1. Empiezan por // y finalizan con el final de la línea. • // Esto es un comentario. • Formato 2. Empiezan por /* y finalizan por */. No es posible anidar comentarios con este formato. • /* Esto también es • un comentario */ • /* Pero esto que /* parece un comentario válido*/ no lo es */

24. Compilador C para PIC • C específico para los PIC • Las principales diferencias entre compiladores residen en las directivas (pre-processor commands) y en las funciones integradas (built-in functions). • Al final de esta sección se incluyen sendas listas con las directivas y las funciones integradas correspondientes al compilador de CCS. • Directivas de preprocesado más habituales: • #ASMLas líneas entre estas dos directivas deben ser instrucciones • #ENDASMensamblador que se insertan tal y como aparecen. • #BIT id=x.ySe crea una variable tipo bit correspondiente al bit y del byte x • en memoria. • #BYTE id=xSe crea una variable y se sitúa en el byte x en memoria. Si ya • existía esa variable, se coloca físicamente en la posición • especificada.

25. Compilador C para PIC • C específico para los PIC • #DEFINE id texto El identificador se sustituye por el texto adjunto. • #DEVICE chip Define el micro para el que se escribe el código. • #FUSES options Define la palabra de configuración para la grabación del • microcontrolador. • #INCLUDE <fichero> Se incluye el texto del fichero especificado en el • #INCLUDE “fichero” directorio o fuera de él. • #INLINE La función que sigue a esta directiva se copia en memoria de • programa cada vez que se le llame. Puede servir para • mejorar la velocidad. • #SEPARATE La función que sigue a esta directiva se implementa de • manera separada (no INLINE). De esta manera se ahorra • ROM

26. Compilador C para PIC • C específico para los PIC • #ORG start Sitúa el código a partir de una determinada posición de la • memoria de programa • #INT_xxxxIndica que la función que sigue es un programa de • tratamiento de la interrupción xxxx. • #INT_GLOBAL Indica que la función que sigue es un programa genérico de • tratamiento de interrupción. No se incluye código de • salvaguarda de registros ni de recuperación como cuando se • usa #INT_xxxx. • #PRIORITY intsEstablece un orden de prioridad en las interrupciones. • #USE DELAY (clock = frecuencia en Hz) • Define la frecuencia del oscilador que se va a utilizar, que se • emplea para realizar los cálculos para funciones integradas • de retardo.

27. Compilador C para PIC • pre-processor commands

28. Compilador C para PIC • built-in functions

29. Compilador C para PIC • built-in functions

30. Compilador C para PIC • PIC C COMPILER • INICIO > PIC-C > PIC C COMPILER • Se puede Crear o abrir un fichero (FILE > NEW / OPEN) o crear un proyecto (conjunto de ficheros y opciones de compilación que se utilizan en un programa). Los proyectos tienen la extensión PJT. • Para crear un nuevo proyecto PROJECT > NEW > PIC WIZARD / MANUAL CREATE

31. Compilador C para PIC • PIC C COMPILER PCB (12bit) PCM (14bit) PCH (PIC18) COMPILAR (F9) MONTARLO

32. Compilador C para PIC • GESTION DE PUERTOS • Existen dos opciones para configurar y manejar los puertos E/S • Definiendo los registros como variables localizadas en RAM. Se definen los puertos y los registros de dirección como variables de C y se colocan en las posiciones reales de estos registros en la memoria RAM de datos. Constituye la manera más directa de trabajar con los puertos E/S. • Usando las funciones integradas específicas del compilador. Se definen la dirección de datos si es necesario y se gestionan las entradas y las salidas mediante funciones relativas al manejo de todo el puerto o de bits particulares del mismo. • Cuando se usan las funciones integradas del compilador de CCS, el código que introduce el compilador puede variar en cuanto a tamaño y tiempo de ejecución. Dependerá de la activación de ciertas directivas de preprocesado: • #USE FAST_IO- #USE FIXED_IO - #USE STANDARD_IO

33. Compilador C para PIC • GESTION DE PUERTOS: POR RAM • OPCIÓN 1. Definiendo los registros en la RAM. Se definen los registros PORTx y TRISx como bytes y se sitúan en la posición correspondiente de la memoria RAM. La directiva C utilizada es #BYTE: • #BYTE variable=constante; • #BYTE TRISA = 0x85 //Variable TRISA en 85h. • #BYTE PORTA = 0x05 //Variable PORTA en 05h. • #BYTE TRISB = 0x86 //Variable TRISB en 86h. • #BYTE PORTB = 0x06 //Variable PORTB en 06h. • Una vez definidas estas variables se pueden configurar y controlar los puertos mediante comandos de asignación.A partir de este punto, estas variables permiten controlar los puertos y se pueden utilizar en sentencias de asignación. • TRISA = 0xFF; // 8 terminales de entrada • TRISB = 0x00; // 8 terminales de salida • TRISC = 0x0F; // 4 pin de mayor peso OUT,4 pin de menor peso IN

34. Compilador C para PIC • GESTION DE PUERTOS: POR RAM • Escritura en los puertos: • PORTC = 0x0A; // salida del datos 00001010 por el puerto C • Lectura de puertos: • valor = PORTA; // Asigna el dato del puerto A a la variable valor. • Manejo de sentencias: • TRISD=0x0F; • if (PORTD & 0x0F) PORTD |= 0xA0; //comprueba los 4 terminales de • // menor peso del puerto D y si son • // 1111 saca por los 4 terminales de • // mayor peso el dato 1010.

35. Compilador C para PIC • GESTION DE PUERTOS: POR RAM • El compilador de CCS incorpora una serie de funciones integradas que permite manejar los bits de una variable previamente definida. • bit_clear (var,bit); //Pone a 0 el bit específico (0 a 7) de la variable. • bit_set (var , bit); //Pone a 1 el bit específico (0 a 7) de la variable. • bit_test (var , bit); //Muestra el bit específico (0 a 7) de la variable. • swap (var); //Intercambia los 4 bits de mayor peso por los 4 • //de menor peso de la variable. • bit_set (PORTC , 4); //”saca” un 1 por el terminal RC4 • if (bit_test(PORTB,0)==1) bit_clear(PORTB,1); //si RB0 es 1 borra RB1 • También se puede declarar un bit de un registro con una variable mediante la directiva #BIT y trabajar directamente con la variable. • #BIT nombre = posición.bit #BIT RA4 = 0x05.4 • ...... • RA4 = 0;

36. Compilador C para PIC • GESTION DE PUERTOS: POR RAM Ejemplo: LED CONTROLADO POR BOTON COMPILAR (F9) MONTARLO

37. Compilador C para PIC • GESTION DE PUERTOS: POR DIRECTIVAS • OPCIÓN 2. Usando funciones integradas del compilador. • El compilador de CCS incorpora una serie de funciones integradas orientadas a trabajar con los puertos E/S. • output_X (valor); //Por el puerto correspondiente se saca • // el valor (0-255). • input_X(); //Se obtiene el valor en el puerto correspondiente. • set_tris_X(valor); //Carga el registro TRISx con el valor (0-255). • port_b_pullups (valor); //Mediante valor=TRUE o valor=FALSE habilita o • //deshabilita las resistencias de pull-up en PORTB.

38. Compilador C para PIC • GESTION DE PUERTOS: POR DIRECTIVAS • Hay una serie de funciones asociadas a un terminal o pin*. El parámetro pin* se define en un fichero include (por ejemplo, 16F876.h) con un formato del tipo PIN_Xn, donde X es el puerto y n es el número de pin. • #define PIN_A0 40 • #define PIN_A1 41 • output_low (pin*); //Pin a 0. • output_high (pin*); //Pin a 1. • output_bit (pin* , valor); //Pin al valor especificado. • output_toggle(pin*); //Complementa el valor del pin. • output_float (pin*); //Pin de entrada, quedando a tensión flotante • input_state(pin*); //lee el valor del pin sin cambiar su sentido • input(pin*); // lee el valor del pin.

39. Compilador C para PIC • GESTION DE PUERTOS: POR DIRECTIVAS • La generación de código para las funciones output_x( ) e input_x( ) depende de la última directiva del tipo #USE *_IO que esté activa. • #USE FAST_IO (PUERTO) [PUERTO: A…] • Cada vez que se emplea una función output...() se saca el valor directamente al puerto, y cada vez que se emplea una función input...() se lee el puerto, pero no se modifican previamente el registro TRIS correspondiente. • El usuario debe asegurarse de que los registros TRIS están cargados adecuadamente antes de llamar a las funciones. • Ej. #USE FAST_IO (B) • #USE STANDARD_IO (PUERTO) [PUERTO: A…] • Cada vez que se emplea una función output...() se inserta código previo para forzar a que el bit particular o el puerto completo sean de salida (mediante la carga del TRIS correspondiente). Si se trata de una función input...() se carga código para definir bit o puerto completo como de entrada. • Ésta es la opción activa por defecto. • Ej. #USE STANDARD_IO (C)

40. Compilador C para PIC • GESTION DE PUERTOS: POR DIRECTIVAS • #USE FIXED_IO (PUERTO_OUTPUTS=pin* , ...) [PUERTO: A…] • Se genera código relativo a la dirección de los datos de manera previa cada vez que aparece una función integrada del tipo input…( ) ó output…( ), pero los pines se configuran de acuerdo con la información que acompaña a la directiva (sólo se indican los pines de salida) y no dependiendo de que la operación sea de entrada o de salida como sucede con #USE STANDARD_IO(PUERTO) • Ej. USE FIXED_IO (B_OUTPUTS = PIN_B2 , PIN_B3) • El efecto de colocar una u otra directiva se puede observar en los ficheros *.lst que se generan como resultado de la compilación. En general se puede decir que resulta más cómodo gestionar los pines de E/S de modo STANDARD, pero haciéndolo de modo FAST se adquiere más control de lo que se le está mandando al PIC y se optimiza código.

41. Compilador C para PIC GESTION DE PUERTOS: POR DIRECTIVAS

42. Compilador C para PIC • GESTION DE PUERTOS: POR PUNTEROS • La memoria se puede acceder en C usando punteros. Los punteros deben ser del tipo INT. • #define portb (int *) 0x06 • portb es un puntero INT cuyo valor es la dirección del bus del dispositivo. El puerto es accesible mediante el uso del operado *. • int p • p = *portb • En este ejemplo el valor del dato en el puerto direccionado en la posición de memoria 0x06 (puerto B) es asignado a la variable p. Antes de que el puerto sea leido es necesario establecer si es de entrada o salida • #define trisb (int *) 0x86 • *trisb = 0xFF

43. Compilador C para PIC • GESTION DE PUERTOS: POR PUNTEROS • Los pines pueden escritos o leidos mediante operadores lógicos. • *portb |= 0b00000100; pone el pin 2 del portB a 1 • *portb &= 0b11111011; pone el pin 2 del portB a 0. • Para lee el valor del pin 7 del portB: • If (*portb & 0b10000000) {…..

44. Compilador C para PIC GESTION DE PUERTOS: POR PUNTEROS

45. Compilador C para PIC Ejemplo: DISPLAY LCD con driver HD44780 1.- Vss (Masa) 2.- Vcc (Alimentación de 2.7V a 5.5V) 3.- Ajuste de contraste (de 0 a 5.5V) 4.- RS (selección de registro) 5.- R/W (lectura/escritura) 6.- E (enable) 7.- D0 (dato LSB) 8.- D1 9.- D2 10.- D3 11.- D4 12.- D5 13.- D6 14.- D7 (dato MSB)

46. Compilador C para PIC Ejemplo: DISPLAY

47. Compilador C para PIC • Ejemplo: DISPLAY • LCD en el compilador C de CCS • El compilador C de CCS incluye un driver para manejar LCD, el fichero que define las funciones indicadas a continuación. • lcd_init (); • Debe llamarse antes que ninguna otra función del fichero LCD.C. • Tal y como aparece en el fichero, además de borrar el display, configura el LCD para trabajar como sigue: • a) En formato de 4 bits, con dos líneas y con caracteres de 5×8 puntos. • b) Con display encendido, cursor apagado y sin parpadeo. • c) Con autoincremento del puntero de direcciones y sin desplazamiento • del display real. • lcd_gotoxy (x , y); • Establece la posición del LCD a la que se debe acceder. • Recuérdese que la primera posición de la primera línea tiene coordenadas (1 , 1), y que la primera posición de la segunda línea es la (1 , 2).

48. Compilador C para PIC • Ejemplo: DISPLAY • lcd_putc (dato); • Escribe dato en la posición a la que apunta el puntero de direcciones. • La variable dato es de tipo char, y se definen algunos caracteres especiales: • \f Borra el display • \n Se posiciona en el inicio de la segunda línea • \b Retrocede una posición • lcd_getc (x , y); • Devuelve el carácter que ocupa la posición (x , y) del LCD. • Por defecto, este driver usa siete bits del puerto B para establecer la comunicación entre el LCD y el microcontrolador (aunque también se puede utilizar el puerto D). • B0 Enable B4 Bit de datos D4 • B1 RS B5 Bit de datos D5 • B2 R/W B6 Bit de datos D6 • B3 - B7 Bit de datos D7

49. Compilador C para PIC • Ejemplo: DISPLAY • También es posible escribir en el LCD usando la siguiente función. • printf(lcd_putc,cadena,vars); • cadena: Cadena de caracteres que puede formarse usando el contenido de una o más variables. • vars: Variables incluidas en la cadena (separadas por comas). • Para indicar la posición y el tipo de las variables a incluir en la cadena, se usa el formato %nt, donde n es opcional. • n: 1-9 Indica el número de caracteres a mostrar • (opcional) 01-09 Indica el número de ceros a la izquierda • 1.1-9.9 Indica cuántos decimales se han de mostrar • t: c Carácter e Flotante (formato exp) • s Cadena o carácter f Flotante truncando • u Entero sin signo lu Entero largo sin signo • x ó X Entero hexadecimal lx ó lX Entero largo hexadecimal • d Entero con signo ld Entero largo con signo • g Flotante rendondeado • w Entero sin signo. La 1ª cifra indica el total, la 2ª el nº de • decimales

50. Compilador C para PIC • Ejemplo: DISPLAY • Algunos ejemplos. • printf(lcd_putc , ”Hola”); • printf(lcd_putc , ”Tecla %c pulsada %u veces” , key , cont ); • Ejemplos de formato. • Especificador Valor=0x12 Valor=0xfe • %03u 018 254 • %u 18 254 • %2u 18 ??? • %5 18 254 • %d 18 -2 • %x 12 fe • %X 12 FE • %4X 0012 00FE • %3.1w 1.8 25.4