RESEÑA DE

LENGUAJE C
VARIABLES
La función main.

Es el punto de entrada al programa.

void main(void)
{
Aquí escribo mi programa
}
Tipos de datos. Char.

El char es una variable de 1 byte.

Almacena números enteros.

Toda variable debe ser declarada.

Ej:
void main(void)
{
char a;
a = 3;
}
Asignaciones

Permiten darle valores a las variables.

Ej:
PTBD_PTBD3 = 1;
PTBD = 0xff;
a = b + c;
Tipos de datos. Int.

El int es una variable de 2 bytes.

Almacena números enteros.

Ej:
void main(void)
{
int b;
b = 1000;
}
Tipos de datos. Float.

Permite almacenar números de punto flotante.

Ej:
void main(void)
{
float c;
c = 10.8;
}
Alternativas al tipo float

En general queremos representar cifras

del tipo: 20,3 mV

Se trata de un número decimal de punto
fijo.

Tampoco se dispone de representación
en punto fijo.
 Solución:
Trabajar las mangintudes
multiplicadas x10, x100, …
La cifra 20,3 se almacena como
203. Así puede contenerse en un
tipo int.
Conversión o casting.

Asignar un tipo de variable a un tipo distinto.

Se usar el operador de conversión.
Ej: Asignar a una variable int un tipo float.

void main(void)
{
int a;
float b, c;
b = 3;
c = 4;
a = (int) b + 1;
}
Modificadores. Un/Signed.

Permiten signar las variables o ampliar

su rango.
void main(void)
{
signed char d;
unsigned char e;
}
Modificadores. Long/Short.

Permiten ampliar el tamaño de un dato

int.
Ej:
void main(void)
{
long int a;
a = 100000;
}
Modificadores. Double.

Permite extender un dato float.

Ej:
void main(void)
{
double g;
long double h;
}
Modificadores. Resumen.
Tipo Tamaño Rango
char 1 byte -128 a +127
unsigned char 1 byte 0 a +255
signed char 1 byte -128 a +128
int 2 bytes -32768 a +32767
unsigned int 2 bytes 0 a +65535
signed int 2 bytes -32768 a 32767
short 2 bytes -32768 a 32767
long 4 bytes -2147483648 a +2147483647
unsigned short 2 bytes 0 a +65535
unsigned long 4 bytes 0 a +4294967295
Registros dedicados.

Son periféricos mapeados en RAM.
Ej: puertos, timers, etc.

PTAD_PTAD0
PTAD
PTBD_PTBD1
PTBD

void main(void)
{
PTAD_PTAD0 = PTBD_PTBD1;
}
OPERACIONES
Operaciones aritméticas. Resumen.

Operador Operación
+ Suma
- Resta
* Multiplicación
/ División
% Resto de la división
- Cambio de signo
++ Incremento
-- Decremento
Operaciones aritméticas.
void main(void)
{
int a, b, c, d, e, f;
a = 1;
b = 2;
c = a + b;
d = a – b;
e = a * b;
f = a / b;
}
No necesariamente existe en
ensamblador una instrucción
para realizar cierta operación
aritmética. Ej: Los PIC 16F no
cuentan con instrucciones de
multiplicación
En ese caso el compilador debe
generar un algoritmo en assembler
que ejecute esa operación
Operaciones acumulativas.

a = a + 1;
a += 2; ( a = a + 2 )
a++; ( a = a + 1 )
b -= 3; ( b = b – 3 )
c *= 2; ( c = c * 2 )
d /= 10; ( d = d / 10 )
Operaciones lógicas. Resumen.
Operador Operación

| OR bit a bit

& AND bit a bit

^ XOR bit a bit

~ negación

>> desplazamiento a la derecha

<< desplazamiento a la izquierda

Operaciones lógicas. Ejemplos.

banderas = banderas | 0x01;

v = v & 0xfd;
PTBD = PTBD ^ 0x01;
PTBD_PTBD0 = ~PTBD_PTBD0;
Desplazamientos. Ejemplos.

PTBD = PTBD << 1; ( ROL PTBD )

a = c >> 4; ( ROR c, ROR c, ROR c,
ROR c )
Manejo de bits como variables

Es válida aplicar una asignación a un bit.

Son válidas las operaciones lógicas
entre bits |, & y ^.

Ejemplos:

Freescale:
PTAD_PTAD4 = 1;

PIC:
PORTBbits.RB4 = 0;
Constantes.

Se permiten constantes numéricas y

alfanuméricas.
Ej:
#define TOTO 4
#define LED PTBD_PTBD0
 CICLOS Y
COMPARACIONES
Acciones básicas.

Secuencias.

Repeticiones.

Selecciones.
Repeticiones. For.

Permite repetir sentencias hasta que se

cumpla una condición.
Ej:
for(i = 0; i < 10; i++)
{
PTBD_PTBD0 = ~PTBD_PTBD0;
}
Uso del for

for( i = 0; i < 10; i++)

Condición de
Condición de Condición de incremento
arranque ejecución
( MIENTRAS
QUE )
Ejemplo de for
for(i = 0; i < 10; i++) Valor de i Condición i < 10 Próximo valor de i
{
0 Se cumple 1
PTAD_PTAD0 = 1;
} 1 Se cumple 2

2 Se cumple 3

3 Se cumple 4

4 Se cumple 5

5 Se cumple 6

6 Se cumple 7

7 Se cumple 8

8 Se cumple 9

9 Se cumple 10

10 Se cumple ---
Expresiones relacionales y lógicas.

Operador Operación

> Mayor

< Menor

== Igual

!= Distinto

>= Mayor o igual

<= Menor o igual

Expresiones relacionales y lógicas. Ejemplos.

a>7
b<c
d==3
k!=j
x>=320
y<=240
(i>0)&&(i<10)
(beta!=13)||(beta<‘z’)
!(x<128)
Repeticiones. While.

El for se presta para repetir código n veces.

El while es apropiado para repetir código
mientras se cumpla una condición.
Ej:
while(PTAD_PTAD0 == 1)
{
PTBD_PTBD0 = 1;
}

PTBD_PTBD0 = 0;
Demoras. Código en C.

Con sentencias en C es difícil determinar

el tiempo de demora.
Ej:
for(i = 0; i < 100000; i++)
{
}
Demoras. Código en assembler.

Usa la directiva asm.

Puede determinarse el tiempo de la demora.
Ej:
void main(void)
{
unsigned char contador_1;

asm
{
LDA #$FA
STA contador_1;
dem_1s_1:
NOP
NOP
NOP
DBNZ contador_1,dem_1s_1
}
}
Demoras. Código en C y assembler.

Usa un núcleo básico en assembler.

Un for multiplica esa demora.
Ej:
void main(void)
{
unsigned char contador_1;
unsigned char contador_2;

for(contador_2 = 0; contador_2 < 10; contador_2++)

{
asm
{
LDA #$FA
STA contador_1;
dem_1s_1:
NOP
NOP
NOP
DBNZ contador_1,dem_1s_1
}
}
}
Selecciones. If.

Permite ejecutar código si se cumple una condición.

if(condición_1)
{
grupo de sentencias 1
}
else if(condición_2)
{
grupo de sentencias 2
}
else if(condición_3)
{
grupo de sentencias 3
}
else
{
grupo de sentencias 4
}
Selecciones. If. Ejemplo.
if(numero == 0)
{
PTBD = 0x3f;
}
else if(numero == 1)
{
PTBD = 0x06;
}
else if(numero == 2)
{
PTBD = 0x5b;
}
else….
FUNCIONES
Funciones.

Una función es una subrutina.

Una función debe ser declarada.

Una función debe ser definida.

Una función puede ser invocada.
Funciones. Declaración.

Damos a conocer al compilador su existencia.

Las declaraciones suelen hacerse antes de la
función main.
Ej:
void demora(void);

void main(void)
{
…
}
Funciones. Definición.

Es el código de la función.

Ej:
void demora(void)
{
unsigned char contador_1;

asm
{
LDA #$FA
STA contador_1;
dem_1s_1:
NOP
NOP
NOP
DBNZ contador_1,dem_1s_1
}
}
Funciones. Invocación.

Es la llamada a la subrutina o función.

No hace falta de una instrucción como
CALL o JSR.
Ej:
void main(void)
{
demora();
}
Accesibilidad de variables.

Cada función tiene un área de datos.

Las variables de una función se
almacenan en su área de datos.

Las funciones no pueden acceder a las
áreas de datos de otras funciones.
Accesibilidad de variables. Ejemplo.
void main(void)
{
unsigned char a; a
unsigned char contador_1; Área datos
main contador_1
demora();
}

void demora(void)
{
unsigned char contador_1; Área datos contador_1
asm demora
{
LDA #$FA
STA contador_1;
dem_1s_1:
NOP
NOP PILA o
NOP
DBNZ contador_1,dem_1s_1 STACK
}
}
Comunicación entre funciones

función func_a función func_b

char
char
int
int
float
float

char, int, float …

char, int, float …
Pasaje de parámetros

Al igual que en un computadora, la pila se

utiliza para el pasaje de parámetros:

int funcion(char a, int b, float c,….)

Ejemplo de pasaje de parámetros
usando la pila
void main(void) main sum
{
int dunga, donga;
dunga ( 3 ) s1 ( 3 )
dunga = 3;
donga = 5; donga ( 5 )
s2 ( 5 )
dunga = suma(dunga, donga);
(8)
donga = resta(dunga, donga); dunga ( 8 )
}

int sum(int s1, int s2)

resta
{
return s1 + s2; dunga ( 8 ) r1 ( 8 )
}
dunga ( 5 ) r2 ( 5 )
int resta(int r1, int r2)
{
return r1 – r2; donga ( 3 ) (3)
}
Pasaje de parámetros.

Permiten comunicar variables de una función a otra.

Ej:
void demora(unsigned char t)
{
unsigned char c, contador_1;

for(c = 0; c < t; c++)

{
asm
{
LDA #$FA
STA contador_1;
dem_1s_1:
NOP
NOP
NOP
DBNZ contador_1,dem_1s_1
}
}
}
Pasaje de parámetros. Invocación.

Ej:
void main(void)
{
demora(10);
demora(5);
}
Devolución de valores.

Permite que una función devuelva un resultado.

Se devuelve un valor con la sentencia return.
Ej:
unsigned BCD_a_bin(unsigned char a, unsigned
char b, unsigned char c)
{
unsigned char auxiliar;

auxiliar = a * 100 + b * 10 + c;

return auxiliar;
}
Devolución de valores. Invocación.

Ej:
void main(void)
{
unsigned char a, x;

a = 1;
x = BCD_a_bin(5, 4, a);
}
Uso del heap

Se hace declarando variables estáticas

externas, mas conocidas como
VARIABLES GLOBALES.
Ejemplo de pasaje de parámetros
usando el heap
int dunga, donga;
heap main

void main(void) dunga

{
dunga = 3; donga
donga = 5;
suma();
resta(); suma
}

int suma(void)
{
dunga = dunga + donga;
}
resta
int resta(void)
{
dunga = dunga - donga;
}
Pasaje de parámetros usando el
heap
Ventajas: Desventajas:

Pueden anidarse los
La memoria usada
llamados a funciones en el heap no puede
sin que crezca la pila liberarse.
enormemente.
¡CHAU!