Programación en C para sistemas basados en un microprocesador

Presentación del tema: "Programación en C para sistemas basados en un microprocesador"— Transcripción de la presentación:

1 Programación en C para sistemas basados en un microprocesador
Una introducción

2 Objetivos Recordar los conceptos básicos de un lenguaje de alto nivel
Comprender sencillos programas escritos en el lenguaje más empleado: “C” Comparar las características de “C” con las de Java y el lenguaje ensamblador.

3 Lenguajes de alto nivel
Basados en el uso de compiladores o intérpretes Incrementan la productividad (respecto al ensamblador) Estructuras elegantes de control Complejas estructuras de datos Mayor abstracción: Manejo de la pila: funciones Memoria física: variables y tipos Incrementan la seguridad Programación estructurada (sin branches) Control de tipos (coherencia de tamaños y signos) Incrementan la portabilidad (multimáquina) Se dispone de más bibliotecas que facilitan la programación

4 ¿Por qué “C”? Permite un buen control de los recursos de bajo nivel (aunque no tanto como el ensamblador) Permite la programación estructurada Es eficiente en velocidad y tamaño (aunque no tanto como un buen programa de un buen programador en ensamblador) Su uso está muy extendido en programación de sistemas (Linux, Windows, drivers...) Defecto: es fácil cometer errores: No está fuertemente tipado ni es orientado a objetos Permite crear código críptico Es difícil de dominar con maestría

5 Traducción a ensamblador
0200fc linkw %fp,#-4 nop clrl moveq #9,%d0 cmpl 02010c bges 02010e bras moveal addal moveal 02011c addal moveb extbl %d0 moveb extbl %d1 cmpl %d0,%d1 02012a beqs 02012c moveq #1,%d0 02012e bras e moveq #1,%d0 addl bras int stringCmp(char s1[10],char s2[10]) { int i; for (i=0; i<10; i++) { if (s1[i]!=s2[i]) return 1; } return 0; Variables Locales: seguridad, abstrae memoria y pila Bucle: cómodo y estructurado Escribir cómodamente expresiones complejas Esta función compara 2 strings de 10 caracteres cada uno: devuelve 0 si son iguales, o 1 si son diferentes.En C se escribe menos código, es más legible (y mantenible), no nos tenemos que preocupar del manejo de la pila para el paso de parámetros y variables locales, verifica que las comparaciones se realizan entre elementos del mismo tipo (tamaño y signo), Manejo transparente de pila y registros Parameter s1 is at 8(A7) Parameter s2 is at 12(A7) Variable i is at -4(A7) Return value through -4(A7)

6 Proceso de compilación
Main.asg main.o AS Fichero.c Fichero.s Fichero.o GCC AS LD Fichero.dep Fichero.hcf Fichero.elf OBJDUMP

7 “C” versus Java “C” no es un lenguaje orientado a objetos:
No hay clases, objetos, métodos No hay herencia, polimorfismo (no puede haber 2 funciones con el mismo nombre) No hay objetos sino variables No hay métodos de una clase sino funciones No hay excepciones “C” no es un lenguaje interpretado No es “machine-independent”

8 Puntos comunes con Java (I)
Bloques definidos por llaves El ámbito de una variable es el bloque más pequeño que contiene su declaración (salvo para los argumentos de una función) Comentarios: /* ... */ Tipos comunes: Los básicos: void, char, int, float Los modificadores long, short, double, signed y unsigned Definición de nuevos tipos mediante typedef Identificadores: case-sensitive, no deben empezar por un número. Ej: linea5, linea_5, linea_anterior

9 Puntos comunes con Java (II)
Expresiones comunes: Los paréntesis son los elementos más prioritarios, seguidos por los operadores unitarios y por los binarios Operadores aritméticos: + - * / % = -= *= /= I+=5+(5%2); /* I=i+6*/ Operadores lógicos y relacionales: && || ! < <= > >= == != if ((i>0 && i<10) || (j==0) ) { } Operadores de bit y de desplazamiento: & | >> << I=0xf0 & 0x0f; /* I=0 */ I=j<<3; /* ASL de 3 bits*/

10 Puntos comunes con Java (III)
Bucles for (inicialización; condición; iteración) for (i=0; i<10; i++) { } for (int i=0;...) /* ERROR */ while (condición) while (i<10) { i++; } Condiciones: if (<cond>) {} else if (<cond>) {} else { } if (i<0) { } else if (i<10) { } else { } switch (variable) { case valor: {} break; default: {} break;}

11 Tipos enteros : tamaños
El tamaño es dependiente de máquina y de compilador, aunque char es siempre de 8 bits En el ColdFire, con el compilador GCC: short int, signed short int, unsigned short int : 16 bits int, signed int, long int, unsigned long int, signed long int: 32 bits Las variables globales no son inicializadas nunca en el C del EdColdFire!!

12 Variables (asm vs. C) i=0; shi=1; li=2; si=0; sshi=1; sli=2; ui=0;
int i; short int shi=1; long int li=2; signed int si=0; signed short int sshi=1; signed long int sli=2; unsigned int ui=0; unsigned short int ushi=1; unsigned long int uli=2; i=0; shi=1; li=2; si=0; sshi=1; sli=2; ui=0; ushi=1; uli=2; D shi D li D si a D sshi c D sli D ui D ushi D uli c B i clrl c <i> moveq #1,%d0 movew %d0, <shi> e moveq #2,%d0 movel %d0, <li> clrl <si> c moveq #1,%d0 e movew %d0, a <sshi> moveq #2,%d0 movel %d0, c <sli> c clrl <ui> moveq #1,%d0 movew %d0, <ushi> a moveq #2,%d0 c movel %d0, <uli>

13 Tipos enteros : tamaños y conversiones
Conversiones implícitas: Al asignar una variable de un tipo mayor a una variable de tipo menor, se recorta (bits menos significativos) int i=0xfedbca56; short int si=i; /* Equivale a si=0xffff */ Al asignar una variable más pequeña a una mayor, no hay problema Al asignar entre variables de igual tamaño y distinto signo, no se pierden bits, pero puede variar su interpretación signed int si=-1; unsigned int ui; ui=si; /* ui=65535 */

14 Punteros (I) Variables que contienen una dirección de memoria
Como los registros de direcciones Ax: Permiten acceder indirectamente a otras variables int i=0; /* La variable i contiene un 0 */ int *pi; /* declaración de un puntero */ pi=&i; /* El puntero pi contiene la dirección de la variable i */ *pi=2; /* La variable i ahora contiene un 2, el puntero pi no se ve alterado */ i=*pi; /* la variable i sigue conteniendo un 2 */ 2 i $XXX i $XXX $XXX $YYY pi pi $YYY $YYY

15 Punteros (II) También permiten acceder a posiciones del mapa de memoria de entrada y salida #define BASE_PUERTO_S 0x /* Direccion del puerto S */ unsigned char *puertoS=BASE_PUERTO_S; /* El puntero pi contiene la dirección del puerto de salida */ *puertoS=0xff; /* Se envía un $FF al puerto de salida */ En EdColdFire hay funciones para esta labor: Internamente usan punteros (ver m5272gpio.c) void set16_puertoS (UWORD valor) UWORD lee16_puertoE (void) $FF $XX $ $ $ $ puertoS puertoS $YYY $YYY Valor de la variable Posición en memoria Valor de la variable Posición en memoria variable variable

16 Punteros (III) Son un mecanismo de bajo nivel, peligroso
Si no se les da un valor adecuado, pueden acceder a posiciones de memoria no deseadas: int *pi; Este es un puntero que apunta a un lugar indeterminado, por no estar inicializado *pi=3; Como pi puede apuntar a cualquier sitio, podemos estar escribiendo en cualquier punto del mapa de memoria, o incluso fuera de él, (provocando un error de bus o de dirección)

17 Arrays (I) Los array son punteros constantes (no variables) que permiten acceder, de una manera indexada, a una zona de memoria reservada por el compilador automáticamente Dicho puntero constante equivale a la dirección de comienzo del array Por ser una constante, este puntero no se inicializa; se inicializa el contenido de la zona de memoria apuntada El índice del primer elemento es el 0, el del segundo elemento es el 1, etc. Es posible acceder (por error o intencionadamente) a posiciones más allá del tamaño reservado para el array Para copiar un array en otro es necesario copiar elemento a elemento con un bucle

18 Arrays (II) int lista[3]={0,1,2}; int i=3; lista[1]=lista[2];
El array lista contiene 3 números, la variable i contiene un 3 lista[1]=lista[2]; Copia el valor de la posición 2 (que es la última), en la posición 1 (que es la segunda) lista[i]=0; ERROR: modifica la variable i (situada en memoria tras el array) $XXX array $XXX array 1 $XXX+4 2 $XXX+4 2 $XXX+8 2 $XXX+8 i 3 $XXX+12 i $XXX+12

19 Arrays (III) Los arrays de caracteres se suelen llamar strings.
char asignatura[4]=“SED”; asignatura[0]=‘T’; Su tamaño debe ser “la longitud máxima de la cadena de caracteres” + 1, porque su último elemento es un 0 (no el carácter ‘0’). ‘S’ $XXX string ‘T’ $XXX string ‘E’ $XXX+1 ‘E’ $XXX+1 ‘D’ $XXX+2 ‘D’ $XXX+2 $XXX+3 $XXX+3

20 Funciones (I) Permiten dividir un problema en subproblemas
Se implementan como subrutinas El manejo de la pila y el uso de los registros es automático e invisible al programador Admiten argumentos de entrada y de salida Suelen devolver un valor, pero no es obligatorio Si la función no devuelve nada, al llegar a la última llave, realiza el return automáticamente Todo programa en C comienza ejecutando la función llamada main, que en sistemas empotrados no suele tener argumentos de entrada o salida

21 Funciones (II) int suma(int a, int b);
nombre Argumentos int suma(int a, int b); Este es el prototipo de la función, que anticipa al compilador qué argumentos admite Si el cuerpo de la función está antes de la llamada, el prototipo no es necesario void main(void){... int s=suma(10,3);... } /* S contendrá ahora un 13*/ Esta es la llamada a la función para que se ejecute, pasándole 2 parámetros compatibles con lo que establecen el prototipo y el cuerpo de la función int suma(int a, int b){ return a+b; } Este es el cuerpo de la función cuya cabecera coincide con el prototipo previo (salvo en el punto y coma final) Tipo del valor que devuelve

22 Funciones (III) Una variable, pasada como parámetro a una función, no ve modificado su valor original durante la ejecución (paso por valor, copia local) Para modificar, dentro de una función, el valor de una variable externa a la función, debemos pasarla por referencia (pasar su dirección) void suma(int a, int b, int *ps){*ps=a+b;} Por medio del puntero ps (que contiene la dirección de s), escribimos en s el resultado void main(void) {... int s; suma(10,3, &s );...} /* s contendrá ahora un 13*/ Ahora se pasa la dirección de s, para que dentro de la función se pueda acceder a s

23 Funciones (IV) Los argumentos de entrada son variables locales al cuerpo de la función (aunque estén fuera de las llaves) Es posible definir otras variables locales Las variables locales son temporales (se implementan como direcciones en la pila o como registros) El valor que se devuelve también suele ser a través de pila o de registro int suma(int a, int b){ int s=a+b; return s; } La variable local s sólo puede ser usada dentro de la función suma (ámbito). La función devuelve el contenido de s int * suma2(int a, int b) { int s=a+b; return &s; } ERROR: no se puede devolver la dirección de s, porque es local y desaparece cuando se termina de ejecutar la función

24 Bibliografía Brian W. Kernighan & Dennis M. Ritchie “The C Programming Language”, Second Edition. Prentice Hall, Inc., 1988. A. Clements “Microprocessor Systems Design” 3rd ed. PWS-Kent Pub. Co., 1997 H. Schildt “C: Manual de referencia” , Ed. McGraw Hill, 1989