Clase I - Introducción A C

IEE2463
Sistemas
Electrónicos
Programables
Introducción al
lenguaje de programación C
Láminas basadas clases de

Angel Abusleme y Dani Guzmán
2do Semestre 2021

1
Supuestos
● Comenzamos con el supuesto de que se sabe programar
● Con ese supuesto, en esta clase aprenderemos la sintaxis básica del lenguaje C
● No aprenderemos todo C
○ Dejaremos mucho para aprender
○ Pero lo de hoy ayudará a partir escribiendo código propio
● Para probar ejemplos rápidos, recomiendo esto
2
Sistemas Electrónicos Programables - 2do semestre 2021
El lenguaje de programación C
● Creado por Dennis Ritche en Bell Labs, 1972-1973
● Nació de la mano con el sistema operativo UNIX
● Es uno de los lenguajes de programación más
populares
● Permite acceso de bajo nivel a la memoria
● Tiene muchas variantes
● Basado en lenguaje B
3
Ventajas de C
● Es pequeño (sólo 32 keywords)
● Es muy común
● Es estable (no cambia mucho)
● Corre rápido
● Es la base de muchos otros lenguajes
● Es uno de los más fáciles de aprender
4
C vs. lenguajes de más bajo nivel
● C es una elección adecuada si:
○ No necesito un control absoluto sobre todos los recursos del MCU
○ No me preocupa mucho la potencia o la eficiencia de recursos (memoria)
○ Quiero hacer más fácil la programación y reusar código
● Usaré assembly si:
○ Necesito mucha eficiencia en uso de recursos
Incluso puedo combinar ambos en forma combinada...
5
Terminología
● Código fuente (source code): es el código del programa, es lo que se escribe para
programar
● Compilar (compile/build): convertir el código fuente en algo que la máquina pueda
entender
● Directiva de preprocesador: pre-procesa el código antes que el compilador
● Ejecutable: Programa compilado que puede correr en la máquina
● Biblioteca (library): Funciones que pueden ser agregadas al programa para ejecutar
ciertas tareas
● Encabezado (header file): Archivo .h incluido al principio del código fuente
○ Incluyen declaraciones (no definiciones) de funciones y macros
○ El código del .h es agregado al código fuente al compilar
6
Constantes al compilar
● Es una directiva del preprocesador
● Cada vez que el compilador lee el nombre de la constante, lo reemplaza por la
expresión
● El compilador no reserva espacio en memoria para estas constantes
● Usualmente las escribimos en mayúsculas
Ejemplo:
#define CONST_NAME constant value or expression
Generalmente en el MSP430 usamos mayúscula para referirnos a nombres simbólicos que

declaran la dirección de algún periférico o registro, ej: P1OUT, declarados en
msp430f5529.h
7
Hello, World
#include <stdio.h> // Directivas de Preproc.
int main() // Función principal
{ // Llaves definen bloques de código
printf("Hello, World!"); // Imprimir en salida estándar
return 0; // Si devuelve 0 es porque
// concluyó sin errores
} // No olvidar cierre de llave
● A C no le importan los espacios o los saltos de línea

● La indentación no es obligatoria, pero es buena
● Cada instrucción termina con ;
● Comentarios son // hasta el final de la línea, o
● /* */ para demarcar comentarios
En general en MSP430 la función main toma void y retorna void

8
Keywords (palabras reservadas) de C
● Control de flujo (6) – if, else, return, switch, case, default
● Loops (5) – for, do, while, break, continue
● Tipos de datos comunes (5) – int, float, double, char, void
● Estructuras (3) – struct, typedef, union
● Enumerar y medir tamaño (2) – enum, sizeof
● Tipos de datos extraños, pero igual usados (7) – extern, signed, unsigned,
long, short, static, const
● Palabras reservadas que no hay que usar nunca (1) – goto
● Palabras raras (3) – auto, register, volatile
9
Tipos de variables
● En C debemos declarar los tipos de todas las variables
○ Con eso indicamos cuánta memoria ocupa cada una
○ Además evitamos errores de tipeo en los nombres
● Cada variable tiene un tipo y un nombre
● Las declaraciones de los tipos de variable van todas juntas al principio de main o de
una función
● Hay varios tipos: int, double, float, char, signed, unsigned, short,
const
● Diferentes tipos tienen diferentes espacios reservados en memoria
○ Se profundizará más adelante
● Sólo el compilador puede acceder a los registros del MSP430
10
Tipos de variables en C para MSP430
11
Nombres de variables
● Usamos cualquier nombre que no sea palabra reservada, usando letras, números y _
● Es importante elegir nombres buenos
int a,b; int start_time;

double d; int no_students;
/* This is double course_mark;
a bit cryptic */ /* This is a bit better */
● Es saludable comentar cada nombre de variable para saber qué es
12
Tipo char
● char guarda un caracter ASCII (8 bits, número de 0 a 255)
● Podemos imprimir un char usando %c
● Un char lleva comillas simples - no dobles
● Ejemplo:
int main()
{
char a, b;
a= 'x'; /* Set a to the character x */
printf ("a is %c\n",a);
b= '\n'; /* This really is one character*/
printf ("b is %c\n",b);
return 0;
}
13
Otros tipos
● unsigned indica que el int o char es sólo positivo
○ signed indica que puede ser positivo o negativo
● long indica que int, float o double tienen más precisión
○ short, en cambio, indica menos precisión
● const indica un parámetro - una variable que no cambia
○ útil en constantes físicas como pi o e
short int small_no;

unsigned char uchar;
long double precise_number;
short float not_so_precise;
const short float pi= 3.14;
const long double e= 2.718281828;
14
Variable tipo static
● Indica al compilador que esa variable existe durante toda la vida de la aplicación
○ No debe ser borrada nunca
○ Incluso guardan su valor entre llamados a una misma función
○ El compilador asigna RAM a esa variable y no reasigna a otra variable
15
Variable tipo volatile
● Indica al compilador que el contenido de esa ubicación de memoria puede cambiar
repentinamente, por ejemplo, entre dos instrucciones consecutivas
○ Esto podría ocurrir si la variable es global (visible por cualquier función) y una interrupción
puede cambiar su valor
○ Entonces el compilador no debe optimizar el programa creando copias de esa variable en
registros
○ Las variables tipo volatile tienen una única copia que es accesada por funciones como main y
también ISRs
● El compilador no optimizará variables volátiles
● Usar variables volátiles sólo si se espera que éstas cambien fuera del flujo del
programa main
16
++ y --
● ++ i significa incrementa i y luego úsalo
● i++ significa úsalo y luego incrementa i
int i= 6;
printf ("%d\n",i++); /* Prints 6 sets i to 7 */
int i= 6;
printf ("%d\n",++i); /* prints 7 and sets i to 7 */
● Úselo con cuidado, es fácil confundirse

● Todo lo anterior también se aplica a --
17
Operadores aritméticos
Además de +, -, * y /, también usamos:
+=, -=, *=, /=, -- y % (modulo)
○ -- (resta 1) e.g. cuenta_regresiva--;

○ += (suma a una variable) e.g. a+= 5;
○ -= (resta de una variable) e.g. num_living-= num_dead;
○ *= (multiplica una variable) e.g. no_bunnies*=2;
○ /= (divide una variable) e.g. fraction/= divisor;
○ (x % y) es el residuo cuando x es dividido por y , e.g. remainder= x%y ; (ints solamente)
18
Operadores relacionales
● == comprueba si dos variables son iguales
● != comprueba si dos variables son distintas
● > comprueba si una variable es mayor que otra
● < comprueba si una variable es menor que otra
● >= comprueba si una variable es mayor o igual que otra
● <= comprueba si una variable es menor o igual que otra
● en cambio, = es para asignar, no para comprobar igualdad!!!
19
Operadores lógicos y bit a bit
● && (AND lógico) es 1 sólo si ambos operadores son distintos de 0
● || (OR lógico) es 0 sólo si ambos operadores son 0
● ! (NOT lógico)
● & (AND bit a bit) realiza un AND bit a bit entre los operandos
● | (OR bit a bit) realiza un OR bit a bit entre los operandos
● ^ (XOR bit a bit) realiza un XOR bit a bit entre los operandos
● ~ (NOT bit a bit) complementa el operando (complemento 1)
● << (shift left) realiza shift left sobre una variable, ej: A<<2
● >> (shift right)
20
Veamos si hemos aprendido
¿Qué hacen las siguientes instrucciones?
P1DIR |= 0X04;
P1OUT |= (1<<2);
¿Y estas otras?
P2OUT = 8;
P2OUT ˆ= (1<<5);
21
Casting
● Cast es una forma de hacer que una variable de un tipo parezca temporalmente de
otro tipo.
● Una razón para hacer cast es evitar que una división redondee enteros.
int a= 3;
int b= 4;
double c;
c = (double)a/(double)b;
22
Condicional if-else
if (expresión a ser probada)
{
// Instrucciones ejecutadas si expr. es verdadera
}
else if (expresión a ser probada)

{
// Instrucciones a ser ejecutadas si expresión es verdadera
}
else
{
// Instrucciones a ser ejecutadas si expresión es falsa
}
23
switch-case-break-default
switch (expresión)
{
case constant1:
// instrucciones
break; // sin el break, las expresiones de abajo son ejecutadas
case constant2:
// instrucciones
break;
...
default:
// instrucciones por defecto, opcional
}
24
Loop for
Mejor veamos un ejemplo:
for (i = 1; i < 11; ++i)

{
printf("%d ", i);
}
25
Loop while y do while
while (testExpression)
{
// Instrucciones en el cuerpo del loop
}
---------------------------------------------
do
{
// Instrucciones -- se ejecutan al menos una vez
}
while (testExpression);
26
Funciones (functions)
● Una función es una sub-unidad de un programa, y que ejecuta una tarea específica
○ Es una subrutina
● Ya vimos una función de la biblioteca de C - printf
● Debemos aprender a escribir nuestras propias funciones
● Las funciones toman argumentos (variables) y pueden retornar un argumento
27
Ejemplo de función - máx entre dos números
#include <stdio.h>
int maximum (int, int); /* Prototipo - ya lo veremos más adelante */
int main(int argc, char*argv[]) /* Argumentos son de la línea de comandos */
{
int i= 4;
int j= 5;
int k;
k= maximum (i,j); /* Llama a la función maximum */
printf ("%d es el mayor entre %d y %d\n",k,i,j);
printf ("%d es el mayor entre %d y %d\n",maximum(3,5), 3, 5);
return 0;
}
int maximum (int a, int b) /* Encabezado de la función */
/* Retorna el entero más grande */
{
if (a > b)
return a; /* Retorna el resultado a si a>b */
return b; /* Retorna el resultado b en cualquier otro caso */
}
28
Funciones que llaman a otras funciones
● Una función puede llamar a otra función
○ Dividir y conquistar
int max_of_three (int, int, int); /* Prototipo */

.
. /* Aquí va main y el resto del código */
.
int max_of_three (int i1, int i2, int i3)
/* Devuelve el máximo entre tres enteros */
{
return (maximum (maximum(i1, i2), i3));
}
29
Funciones void
No toman argumentos o no entregan resultado
void print_hello (void); /* prototipo */

void print_hello (void)
/* this function prints hello */
{
printf ("Hello\n");
}
void odd_or_even (int); /* prototipo */
void odd_or_even (int num)
/* this function prints odd or even appropriately */
{
if ((num % 2) == 0) {
printf ("Even\n");
return;
}
printf ("Odd\n");
}
30
Acerca de las funciones
● Una función puede tomar cualquier número de argumentos mezclados de cualquier
forma
● Una función puede devolver a lo más un resultado
○ Hay formas de meter varios datos en un resultado mediante el uso de arreglos y estructuras
● Cuando volvemos de una función, los valores de los argumentos no cambian
○ La función crea una copia de los argumentos y actúa sobre la copia
○ Los cambios sobre la copia no son visibles fuera de la función
● Podemos declarar variables dentro de la función de la misma forma en que lo hacemos
en main()
○ Estas variables serán borradas al retornar de la función
31
¿Dónde ponemos las funciones?
● En general, da lo mismo dónde las ponemos
● main() es una función al igual que cualquier otra, y de hecho podemos llamar a
main() desde otras funciones
● Es común que main() sea la primera función del código
● Las funciones deben estar completamente separadas unas de otras
● Los prototipos de las funciones deben ir antes de usar la función
● Lo típico es poner todos los prototipos, luego main y luego otras funciones
32
¿Qué son los prototypes?
● El prototipo de una función le dice al compilador de C qué esperar de la función
○ Argumentos
○ Tipo de dato del valor de retorno
● Mejor ponerlos antes de main()
● #include encuentra los prototipos para las funciones de biblioteca (e.g., printf)
● Una función DEBE retornar el mismo tipo de variable que declaramos en el prototipo
33
Ámbito o scope de una variable
● El ámbito o scope de una variable es donde puede ser usada dentro del programa
● Normalmente las variables tienen ámbito local
○ Esto significa que sólo pueden ser usadas en la función donde son declaradas
○ Recordemos que main() es una función
● También podemos declarar variables globales
● Si declaramos una variable fuera de una función, puede ser usada en cualquier función
escrita debajo de donde fue declarada
● Hay que tener precaución al usar variables globales.
○ Pueden complejizar el flujo del programa
○ Podría ser más difícil de depurar.
○ Podría ser más difícil de reutilizar un código.
○ Ocuparlas solo si es necesario.
34
Para hacer debugging
● Una buena forma de hacer debugging o depuración es pensar como un computador
● Debes ir por todos los loops del programa y preguntarte por el valor de cada variable
en cada momento
● Cada vez que vas por un loop pregúntate si la condición del loop es cumplida, y si
debes seguir avanzando en el programa
35
Otras técnicas para depurar
● Comprobar cierre de paréntesis y comas
○ el editor puede ayudar con los paréntesis
● Comprobar punto y coma al final de cada línea que lo necesita
● Pon algunos printf para saber qué está haciendo el programa
○ En el caso de un micro, podemos usar LEDs o escribir al puerto serial
● Trata de explicar el programa a otra persona
36
Lecturas y referencias sugeridas
● Compilador de C online
● C de Kernighan y Ritchie, 2a edición
● Libro del curso cap. 5
37

Clase I - Introducción A C

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Clase I - Introducción A C

Uploaded by

Copyright:

Available Formats

IEE2463

Láminas basadas clases de

2do Semestre 2021

Incluso puedo combinar ambos en forma combinada...

#define CONST_NAME constant value or expression

Generalmente en el MSP430 usamos mayúscula para referirnos a nombres simbólicos que

● A C no le importan los espacios o los saltos de línea

En general en MSP430 la función main toma void y retorna void

int a,b; int start_time;

● Es saludable comentar cada nombre de variable para saber qué es

short int small_no;

● Úselo con cuidado, es fácil confundirse

○ -- (resta 1) e.g. cuenta_regresiva--;

else if (expresión a ser probada)

for (i = 1; i < 11; ++i)

int max_of_three (int, int, int); /* Prototipo */

void print_hello (void); /* prototipo */

You might also like