03 Programación C UC8051 PPT 2017 2sem

MICROCONTROLADORES
PROGRAMACIÓN EN
LENGUAJE C
Microcontroladores
Estructura general de presentación:
 Generalidades de programación en C para

microcontroladores
 Particularidades de C para 8051/52

 Compilador de Keil uVision
 Ejemplos de programación
Generalidades de Programación en C para microcontroladores
 Ventajas:
 El lenguaje C es Universal, el assembler es exclusivo del dispositivo.
 Portabilidad del código (sobre todo si no esta relacionado con el hardware)

Permite migrar con facilidad de arquitecturas de 8 a 16 bits.
 Permite la modularización del programa, uso de funciones y POO.
 Facilita el trabajo en equipo y la disponibilidad de programadores.
 Menor tiempo de programación, fácil de modificar y mantener.
 En assembler, en ocasiones, representa un menor costo realizar un nuevo

diseño que actualizar/modificar lo realizado por otro programador.
 Permite acceder desde el assembler a variables de C y a la inversa (con

assembler se puede acceder al hardware en forma directa).
 Un buen compilador realiza el buen uso de los modos de direccionamiento y de

todas las Instrucciones del procesador, cosa que un programador de assembler
poco experimentado no aprovecha.
 Desventajas:
 El código ejecutable generado con un compilador C, ocupa mas espacio en la
memoria de programa.
 En aplicaciones sencillas el lenguaje C se vuelve ineficiente, generando código

redundante que ocupa mas espacio y tarda mas tiempo en ejecutarse.
 No se debe dejar de considerar el assembler cuando se desea optimizar tiempo

de ejecución, memoria flash y RAM.
 Los compiladores tienen costo, los assembler no o es bastante menor.

Se proveen licencias de uso libre para una determinada longitud del programa.
 La concepción del programador en C para sistemas embebidos debe ser

distinta de la que se emplea cuando programa en una PC.
Los parámetros de:
Frecuencia de procesamiento de CPU, Limitación de memoria
de programa y de Datos son completamente distintos.
 Convenciones:
 Las variables deben ser inicializadas al ser declaradas;
 El uso de variables globales debe ser evitado (permanentemente usan memoria);
 Se aconseja en lo posible usar variables locales (la memoria utilizada es luego
liberada);
 Bloques de códigos deben ser agrupados y separados entre ellos por espacios en
blanco o comentarios;
 Comentario en una línea de código: Doble diagonal ( // );
 Bloque de comentarios: Comienza con ( /* ) termina con ( */ );
 Nombres o Identificadores:
 Máximo número de caracteres es 31;
 Solo se usa letras, números o el caracter '_';
 El primer caracter no puede ser número;
 Es sensible a mayúsculas;
 Los bloques de programas deben alinearse por sangrías ó indentación para

identificarlos
5
Ejemplo Código con sangría:
P3OUT |= 0x04;
while(1){
if(!CMBufIsEmpty()){ //polling the command receiver buffer
cmd = CMGetComand(); //get the new command

ACStop();//stops be action being executed
switch (cmd){
case DEMO1: //demo1 procedure
...
}
}
}
6
Declaración de variables:
 Deben ser siempre realizadas al principio del programa;
 Variables Globales: Accesibles en todo el código;
 Variables Locales: declaradas en una función y son solo accesibles durante la

ejecución de dicha función;
 La memoria ocupada por una variable local de una función, será usada por otra
variable en otra función.
 Si una variable es declarada en un bloque de código, solo accesible en ese bloque y

durante su ejecución.
7
Tipos de datos en C (depende del compilador C)
Type Size Representation Range values

[bits]
Minimum Maximum
signed char 8 ASCII -128 127
char, unsigned char 8 ASCII 0 255
short, signed short 16 2’s complement -32768 32767
unsigned short 16 Binary 0 65535
int, signed int 16 2’s complement -32768 32767
unsigned int 16 Binary 0 65535
long, signed long 32 2’s complement -2147483648 2147483647
unsigned long 32 Binary 0 4294967295
float 32 IEEE 32-bit 1.175495e-38 3.40282346e+38
double 32 IEEE 32-bit 1.175495e-38 3.40282346e+38
long double 32 IEEE 32-bit 1.175495e-38 3.40282346e+38
8
 Modificadores de Tipos de datos en C
 const: Constante, se localizan en la memoria de programa
 extern: Se declara una variable que está definida en otro módulo o archivo
 register: Se solicita al compilador que la variable se localice en un registro del

procesador, es más rápido el acceso, es local y esta limitado a la disponibilidad;
 static: Preserva el valor de las variables locales. Le da privacidad a las

variables globales en el archivo que fueron definidas.
 volatile: La variable puede ser modificada fuera del contexto o del flujo normal
del programa, por lo que no debe ser optimizada por el compilador
9
Optimización de un programa en C para sistema embebido.
 La mejor performance de un programa se obtiene cuando:
 El Tamaño del código es reducido
 El tiempo de ejecución es Mínimo
Se puede lograr definiendo el tipo de dato mas apropiado para cada variable
 Los tipos de datos “int” y “long int” deben ser usados solo donde se requieren, considerando el
rango de los datos a representar.
 Las operaciones en doble precisión y punto flotante son ineficientes y deben ser evitadas
donde la eficiencia es importante y los recursos son limitados.
 Usar tipo de dato unsigned donde sea posible; para el tipo char el signo debe definirse
explícitamente.
 Usar variables locales tanto como sea posible (variables Locales usan pila ó registros de CPU,
las variables globales usan RAM);
 Usar punteros para acceder a estructuras y uniones;
 Usar decrementos en los lazos “for”.
10
Operaciones booleanas sobre bits en C estándar
Paraoperar sobre bits individuales, es conveniente expresar los valores constantes en
hexadecimal (0xnn).
Operadores de bits:
 AND: & OR: | NOT: ~ XOR: ^
Operan “bit a bit”, no confundir con los operadores lógicos &&, || y !, utilizados para
relacionar las operaciones condicionales
Por ejemplo:
 Analizar un bit: if (0x20 & reg) { … }; // considerando a reg como char
 Poner en uno los bits 0 y 1: reg |= 0x03; // equivalente a : reg = reg | 0x03
 Poner en cero los bits 7 y 6: reg &= 0x3F; // no confundir & con el operador dirección
 Cambio de estado de un bit : reg ^= 0x0001; // “Toggling”
 Invertir los bits de un registro: ~ reg; o reg = ~ reg;
 Desplazamiento de N posiciones (los lugares libres se completan con ceros) : << N o >> N
Puesta a uno o cero de bit(s), forma alternativa:

 reg= (3 << 1); // reg = 00000100b
 reg = (3 << 1) | (5 << 1) ; // reg = 00010100b
 reg = ~((3 << 1) | (5 << 1)); // reg = ~(00010100b) = 11101011b.
Particularidades de C para 8051/52 –
Compilador de Keil uVision
Particularidades de C para 8051/52 - IDE Keil uVision
Gestión de memoria:
 Memoria de Programa: El tamaño máximo del programa ROM que
permite generar C51 es de 64K.
 RAM: Se admiten tres modelos de memoria, SMALL, COMPACT y
LARGE
 SMALL: Todas las variables se almacenan en la memoria

interna. El acceso a las variables es muy eficiente. Existe
limitación en cuanto al tamaño de la memoria interna.
 COMPACT: Las variables se almacenan en la memoria externa.

Puede almacenar como máximo de 256 bytes.(acceso paginado)
 LARGE: Todas las variables se almacenan en memoria externa

sin limitación. Es el menos eficiente.
Tipos de Memoria
 DATA: 128 bytes; área utilizada por el modelo SMALL
 IDATA; No dependiente del modelo utilizado memoria interna direc. indirecto
 CODE: 64K bytes
 PDATA: 256 bytes; área utilizada por el modelo COMPACT , memoria externa
paginada (acceso en 8 bits con R0 ó R1 direc. Indirecto)
 XDATA; área utilizada por el modelo LARGE
 BDATA; área direccionable por bit
0xFFFF 0xFFFF 0x2F
BDATA
0xFF 0xFF
CODE XDATA 0x1F
0x7F
PDATA IDATA
DATA REG
0x0000 0x0000 0x00 0x00 0x00
Se puede combinar la directiva de compilación (#pragma) y los modificadores de
lugar de residencia de variables y funciones para personalizar el modelo de
memoria utilizado
 Directivas  Modificadores de tipo de memoria
 #pragma SMALL  data
 #pragma COMPACT  idata
 #pragma LARGE  code
 pdata
 xdata
 bdata
 El modelo y tipo de memoria elegido influye en la velocidad y tamaño del código.
 Por ejemplo, suponiendo la instrucción en C int i=520; al compilarlo, en función del
modelo de memoria elegido, quedaría:
DATA IDATA XDATA

Código MOV i,#02 MOV R0 ,#i MOV DPTR,#i
MOV i+1 ,#08 MOV @R0,#02 MOV A,#02
INC R0 MOVX @DPTR,A
MOV @R0,#08 INC DPTR
MOV A,#08
MOVX @DPTR,A
Byte/Ciclos maq. 6/4 7/4 10/9
Rango direcciones 0-7F 0-FF 0-FFFF
 Ejemplo C_STARTUP:
C:0x0000 022014 LJMP C:2014
main:
#pragma SMALL C:0x2000 E4 CLR A

#include "reg51.h" C:0x2001 F508 MOV velocidadMotor(0x08),A
unsigned char velocidadMotor; C:0x2003 902805 MOV DPTR,#0x2805
int xdata miArray[128]; C:0x2006 74FF MOV A,#0xFF
C:0x2008 F0 MOVX @DPTR,A
unsigned char miFuncion(unsigned char data param){ C:0x2009 A3 INC DPTR
unsigned char data variableLocal=10; C:0x200A 74C9 MOV A,#0xC9
param =param + variableLocal; C:0x200C F0 MOVX @DPTR,A
variableLocal++; C:0x200D 7F01 MOV R7,#0x01
return(param); C:0x200F 122020 LCALL miFuncion(C:2020)
} C:0x2012 80FE SJMP C:2012
C:0x2014 787F MOV R0,#0x7F
void main(void){
C:0x2016 E4 CLR A
velocidadMotor=0;
C:0x2017 F6 MOV @R0,A
miArray[3]=-55; (C2=0xffc9)
C:0x2018 D8FD DJNZ R0,C:2017
miFuncion(1); C:0x201A 758108 MOV SP(0x81),#velocidadMotor(0x08)
while(1); C:0x201D 022000 LJMP main(C:2000)
} miFuncion:
C:0x2020 7E0A MOV R6,#0x0A
C:0x2022 EE MOV A,R6
C:0x2023 2F ADD A,R7
C:0x2024 FF MOV R7,A
C:0x2025 22 RET
 Ejemplo
unsigned char miFuncion(unsigned char data param){ miFuncion:

unsigned char data variableLocal=10; C:0x2020 7E0A MOV R6,#0x0A
param =param + variableLocal; C:0x2022 EE MOV A,R6
variableLocal++; C:0x2023 2F ADD A,R7
return(param); C:0x2024 FF MOV R7,A
} C:0x2025 22 RET
unsigned char miFuncionL(unsigned char param) miFuncionL:

{ C:0x20A0 9027FF MOV DPTR,#0x27FF
static unsigned char xdata variableLocal=10; C:0x20A3 E0 MOVX A,@DPTR
param =param + variableLocal; C:0x20A4 2F ADD A,R7
variableLocal++; C:0x20A5 FF MOV R7,A
return(param); C:0x20A6 E0 MOVX A,@DPTR
} C:0x20A7 04 INC A
C:0x20A8 F0 MOVX @DPTR,A
C:0x20A9 22 RET
Tipos de datos de Lenguaje C particulares para C51
Bytes
Tipo de dato Rango Notas
ocupados
bit 1 bit 0,1 Área DATA direccionable por bit
sbit 1 bit 0,1 área SFR
sfr 1 0..255 área SFR
Tipo sfr
Permite declarar un entero positivo en el rango 0…255
Corresponde a una variable en la zona de registros especiales
Se usa igual que un unsigned char
Declaración: sfr nombre_variable = dirección de memoria
Ejemplo:
sfr P0 = 0x80;
sfr P1 = 0x90;
void main (void){
while(1)
P1 = ~P0;
}
Tipos de datos de Lenguaje C particulares para C51 (continuación)
Tipo bit
Permite declarar un entero positivo en el rango de 0 – 1

La variable se crea en la zona direccionable por bit (20h a 2Fh)
Declaración: bit nombre_variable;
Tipo sbit
Permite redefinir posiciones por bit en la zona de los SFR

Direcciones terminadas en 0h u 8h (80h, 88h, 90h…)
Declaración: sbit nombre_variable = dirección de memoria;
Ejemplo:
bit lleno;
sbit valvula = 0x90^0; // bit 0 puerto digital P1, P1.0
lleno = 1;
If (lleno == 1) valvula = 1;
else valvula = 0;
#include <reg51.h>
void main(void)
{
P0=0x35 & 0x0F; //ANDing
P1=0x04 | 0x68; //ORing
P2=0x54 ^ 0x78; //XORing
P0=~0x55; //inversing
P1=0x9A >> 3; //shifting right 3
P2=0x77 >> 4; //shifting right 4
P0=0x6 << 4; //shifting left 4
}
Funciones de atención de interrupciones
 La palabra interrupt n genera un vector de interrupción en la dirección
(8*n+3). En el ejemplo es la dirección 0BH de memoria de código.
 Las variables locales declaradas en la función no se superponen con las
variables del programa principal (trabajo del linker).
 El compilador añade el código necesario para empilar los registros
utilizados (ACC, B, DPTR, PSW, R0-R7) a comienzo de la función.
 Al salir de la función se desempilan los registros anteriores y se inserta un
RETI en lugar de un RET.
Ejemplo:
Rutina de interrupción que cada vez que desborde el Timer0 (vector 0x000b)
incremente una variable tiempo.
volatile long tiempo=0;
void incrementar_tiempo(void) interrupt 1
{
tiempo++;
}
Fuente de Vector de Orden de Bandera de Limpiado por Bandera de Control de

interrupción interrupción prioridad pedido Hardware? habilitación prioridad
Siempre
Reset 0x0000 Top None N/C Siempre alto
Habilitado
External
0x0003 0 IE0 (TCON.1) Y EX0 (IE.0) PX0 (IP.0)
Interrupt0 (/INT0)
Timer 0 OverFlow 0x000B 1 TF0 (TCON.5) Y ET0 (IE.1) PT0 (IP.1)
External
0x0013 2 IE1 (TCON.3) Y EX1 (IE.2) PX1 (IP.2)
Interrupt1 (/INT1)
Timer 1 OverFlow 0x001B 3 TF1 (TCON.7) Y ET1 (IE.3) PT1 (IP.3)
RI0 (SCON.0)
UART 0 0x0023 4 N ES0 (IE.4) PS0 (IP.4)
TI0 (SCON.1)
TF2H (TMR2CN.7)
Timer 2 OverFlow 0x002B 5 N ET2 (IE.5) PT2 (IP.5)
TF2L (TMR2CN.6)
Particularidades de C para 8051/52 –
Ejemplos de programación
Estructura de Programación en C para 8051
#include <reg51.h> /* Inclusión de archivo de cabecera */
#define …….. /* Definiciones de constantes de compilación */
sbit ……. /* Definiciones de variables tipo sbit o bit */
int ……. /* Definiciones de variables globales */

char ……
void inicializacion(void) { /* Definiciones de funciones*/
/* Función main (principal) */

main(){
int ……. /* Definiciones de variables locales */
unsigned char …….
inicializacion(); /* Llamado de funciones */
while (1){
…………………… /*Código de ejecución eterna para sistemas embebidos */
}
}
void MiRutServicioTimer0(void) interrupt 1 { /* Definiciones de rutinas de atención Interrupción */

/* Cogido de rutina de servicio */
}
25
Estructura de Programación en C para 8051
#include <reg51.h>
#define ON 1
sbit tecla = P3^0;
unsigned char duplicar(unsigned char x){

return (2 * x);
}
unsigned char sumoDos(unsigned char x){

return (x + 2);
}
void main(void){
unsigned char primero,segundo;
primero =P1;
if(tecla == ON)
segundo = duplicar(primero);
else
segundo = sumoDos(primero);
while(1);
}
26
Timers
Programa 1 Programa 2 Programa 3
void T0M1Delay(void){ void T0M2Delay(void){ void Timer0Init(void){

TMOD=0x01; TMOD=0x02; TMOD = 0x02;
TL0=0xFD; TH0=-23; TH0 = -23;
TH0=0x4B; TR0=1; ET0 = 1;
TR0=1; while (TF0==0); TR0 = 1;
while (TF0==0); TR0=0; }
TR0=0; TF0=0;
TF0=0; }
sbit mybit=P1^5;
}
void main(void){
sbit mybit=P1^5; sbit mybit=P1^5; Timer0Init();
EA = 1;
void main(void){ void main(void){ while (1);
while (1) { while (1) { }
mybit=~mybit; mybit=~mybit; void timer0() interrupt 1
T0M1Delay(); T0M2Delay(); {
} } mybit=~mybit;
} } }
27
Comunicación serie
BaudRate Clk SMOD TH1 Error
9600 12 1 F9 7%
4800 12 0 F9 7%
2400 12 0 F3 0,16%
void serialInit(void){
SCON = 0x50; /* setup para 8-bit de datos */ 1200 12 0 E6 0,16%
TMOD = 0x20; /* setup timer1 p/ autocarga*/ 9600 11 0 FD 0
TH1 = 0xF3; /* setup para 2400 baudios*/
4800 11 0 FA 0
TR1 = 1; /* enciende timer 1 */
//TI = 1; /* listo p/ transmitir x interrup*/ 2400 11 0 F4 0
} 1200 11 0 E8 0
void main(void){ void main(void){

serialInit(); unsigned char mybyte;
while(1){ serialInit();
SBUF=‘A’; while (1) {
while (TI==0); while (RI==0);
TI=0; mybyte = SBUF;
} P1 = mybyte;
} RI = 0;
}
}
Comunicación serie
void serialInit(void){
SCON = 0x50; /* setup para 8-bit de datos */
TMOD = 0x20; /* setup timer1 p/ autocarga*/
TH1 = 0xF3; /* setup para 2400 baudios*/
TR1 = 1; /* enciende timer 1 */
//TI = 1; /* listo p/ transmitir x interrup*/
ES = 1; /* habilita interrupción serie */
}
void main(void){ void serial0() interrupt 4 {

serialInit(); if (TI==1) {
EA = 1; TI=0;
while (1); }
} else {
P0=SBUF;
RI=0;
}
}
Ejemplos de Programación en C para 8051 para clases prácticas
Se desea construir un dado electrónico basado en el uC 8051.
Número LED on
1 D4
2 D3,D5
3 D3,D4,D5
4 D1,D2,D6,D7
5 D1,D2,D4,D6,D7
6 D1,D2,D3,D5,D6,D7
30
#include “reg51.h” for ( ; ; ) { D4 = ON;
if(button == 0){ D6 = ON
#define ON 0 switch (DADO) { D7 = ON;
#define ALL_OFF 0xFF case 1: break;
D4 = ON; case 6:
sbit button = P3^0; break; D1 = ON;
case 2: D2 = ON;
sbit D1 = P1^0; D3 = ON; D3 = ON;
sbit D2 = P1^1; D5 = ON; D5 = ON
sbit D3 = P1^2; break; D6 = ON;
sbit D4 = P1^3; case 3: D7 = ON;
sbit D5 = P1^4; D3 = ON; break;
sbit D6 = P1^6; D4 = ON } //Fin switch
D5 = ON; wait_a_second();
// Función retardo de ~1seg break; wait_a_second();
void wait_a_second ( ) { case 4: P1 = ALL_OFF;
unsigned int x; D1 = ON; } // Fin if
for ( x = 0; x < 33000; x++); D2 = ON; else {
} D6 = ON DADO++;
D7 = ON; if( DADO == 7 )
// Programa principal break; DADO = 1;
main ( ) { case 5: } // Fin else
// Inicializa variable estado D1 = ON; } // Fin for
int DADO = 0; D2 = ON; } // Fin main
31
Propuesta: se desea codificar de una manera más
eficiente el programa del dado electrónico basado en
el uC 8051.
¿Arreglos?
# LED on Binario P1 Hex
1 D4 11110111 F7
2 D3,D5 11101011 EB
3 D3,D4,D5 11100011 E3
4 D1,D2,D6,D7 10011100 9C
5 D1,D2,D4,D6,D7 10010100 94
6 D1,D2,D3,D5,D6,D 10001000 88
7
32
Se desea construir un buzzer electrónico basado en el uC 8051.
Cuando la llave es presionada, el buzzer enciende y apaga 30
veces con un retardo de un segundo entre salidas.
#include “reg51.h” for(;;){
while(button == 1);
#define ON 0 for( i = 1; i <= 30; i++) {
#define OFF 1 Buzzer = ON;
wait_a_second();
sbit button = P3^0; Buzzer = OFF;
sbit Buzzer = P1^7; wait_a_second();
}
// Función retardo de ~1seg }
void wait_a_second ( ) { }
unsigned int x;
for ( x = 0; x < 33000; x++);
}
// Programa principal
main ( ) {
// Inicializa variable estado
int i;
Buzzer = OFF;
33
Se desea construir un pianito electrónico basado en el uC 8051.
Cuando una llave es presionada, el buzzer enciende a una
frecuencia determinada.
Nota Frecuencia Periodo N veces 50us

C 262 3816 76
D 294 3401 68
E 330 3030 60
F 349 2865 57
G 392 2551 51
A 440 2272 45
B 494 2024 40
C 524 1908 38
34
#include “reg51.h” // Programa principal // Programa principal
main ( ) { case 8:
#define ON 0 unsigned char key_pres; tone = 57;
#define OFF 1 count = 0; break;
Speaker = 0; case 16:
sbit Speaker = P3^0; init_timer ( ); tone = 51;
int count, tone; EA = 1; break;
for(;;){ case 32:
void init_timer ( ) { if(P1 != 0xFF){ tone = 45;
TMOD = 0x20; // T1 en M2 TR1 = 1; break;
TH1 = -50; //T1 em 50us key_pres = ~P1; case 64:
ET1 = 1; switch(key_pres){ tone = 40;
TR1 = 0; //Arranca parado case 1: break;
} tone = 76; case 128:
// T1 servicio de interrupción break; tone = 38;
Timer1_ISR( ) interrupt 3 { case 2: break;
count++; tone = 68; }
if( count == tone) { break; }
count = 0; case 4: else{
Speaker = ~Speaker; tone = 60; count = 0;
} break; Speaker = 0;
} TR1= 0;
}
}
}
35
Ejemplos de Programación en C para 8051para clases prácticas
Arreglos
 Escribir un programa en C para 8051 que envíe los valores
hexadecimales en ASCII 0, 1, 2, 3, 4, 5, A, B, C, y D por el puerto P1.
Solución:
#include <reg51.h>
void main(void)
{
unsigned char mynum[]=“012345ABCD”;
unsigned char z;
for (z=0;z<=10;z++)
P1=mynum[z]; // o P1 = * (mynum + z)
while(1);
}
 Escribir un programa en C para 8051 que envíe los valores 0-9 en

código 7-segmentos por el puerto P1.
código 7-segmentos por el puerto P1 y P2.
36
Ejemplos de Programación en C para 8051para clases prácticas
Arreglos
código 7-segmentos por el puerto P1.

código 7-segmentos por el puerto P1 y P2.
37
 Operadores Aritméticos:
Operator Name Syntax

Unary Plus +a
Addition (Sum) a+b
Prefix Increment ++a
Postfix Increment a++
Assignment by Addition a += b
Unary Minus (Negation) -a
Subtraction (Difference) a-b
Prefix Decrement --a
Postfix Decrement a--
Assignment by Subtraction a -= b
Multiplication (Product) a*b
Assignment by Multiplication a *= b
Division (Dividend) a/b
Assignment by Division a /= b
Modulus (Remainder) a%b
Assignment by Modulus a %= b
38
 Operadores Relacionales:

Less Than a<b
Less Than or Equal To a <= b
Greater Than a>b
Greater Than or Equal To a >= b
Not Equal To a != b
Equal To a == b
Logical Negation !a
Logical AND a && b
Logical OR a || b
39
 Otros operadores:
Basic Assignment a=b
Function Call a()
Array Subscript a[b]
Indirection (Dereference) *a
Address-of (Reference) &a
Member by Pointer a->b
Member a.b
Member by Pointer Indirection a->*b
Member Indirection a.*b
Cast (type) a
Comma a,b
Ternary Conditional a?b:c
Scope Resolution a::b
Size-of sizeof a
Size-of sizeof (type)
Type Identification typeid type
Allocate Storage new type
Allocate Storage (Array) new type[n]
Deallocate Storage delete a
Deallocate Storage (Array) delete[] a
40
 Formas compactas:
Compact form Original form
x += y x=x+y
x -= y x=x-y
x *= y x=x*y
x /= y x=x/y
x %= y x=x%y
x &= y x=x&y
x |= y x=x|y
x ^= y x=x^y
x << y x = x << y
x >> y x = x >> y
41
 Prioridad de operadores:
Priority Operator Description
Highest () [] -> Grouping, scope, array/member access
! ~ + - & Size of type cast (most) unary operations, …
* / % Multiplication, division, modulo
+ - Addition, subtraction
<< >> Bitwise shift left and right
< <= > >= Comparisons: less-than, ...
== != Comparisons: equal and not equal
& Bitwise AND
^ Bitwise exclusive OR
| Bitwise inclusive (normal) OR
&& Logical AND
|| Logical OR
? Conditional expression (ternary operator)
= += -= *= /= %= &= |= ^= <<= >>= Assignment operators
Lowest . Concatenation ("comma“)
42
 Operadores de bits en variables:

Bitwise Left Shift a << b
Assignment by Bitwise Left Shift a <<= b
Bitwise Right Shift a >> b
Assignment by Bitwise Right Shift a >>= b
Bitwise One's Complement ~a
Bitwise AND a&b
Assignment by Bitwise AND a &= b
Bitwise OR a|b
Assignment by Bitwise OR a |= b
Bitwise XOR a^b
Assignment by Bitwise XOR a ^= b
43
 Bit shifts: Rotación izquierda

 Operador: ( << );
 Example: x = y << 2;
 Bit shifts: Rotación a la derecha (con carry)

 El bit de signo es preservado;
 Operator: ( >> );
 Example: x = y >> 1;
44

03 Programación C UC8051 PPT 2017 2sem

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

03 Programación C UC8051 PPT 2017 2sem

Caricato da

Copyright:

Formati disponibili

MICROCONTROLADORES

 Generalidades de programación en C para

 Particularidades de C para 8051/52

 Portabilidad del código (sobre todo si no esta relacionado con el hardware)

 Permite la modularización del programa, uso de funciones y POO.

 Facilita el trabajo en equipo y la disponibilidad de programadores.

 Menor tiempo de programación, fácil de modificar y mantener.

 En assembler, en ocasiones, representa un menor costo realizar un nuevo

 Permite acceder desde el assembler a variables de C y a la inversa (con

 Un buen compilador realiza el buen uso de los modos de direccionamiento y de

 En aplicaciones sencillas el lenguaje C se vuelve ineficiente, generando código

 No se debe dejar de considerar el assembler cuando se desea optimizar tiempo

 Los compiladores tienen costo, los assembler no o es bastante menor.

 La concepción del programador en C para sistemas embebidos debe ser

 Los bloques de programas deben alinearse por sangrías ó indentación para

cmd = CMGetComand(); //get the new command

 Deben ser siempre realizadas al principio del programa;

 Variables Globales: Accesibles en todo el código;

 Variables Locales: declaradas en una función y son solo accesibles durante la

 Si una variable es declarada en un bloque de código, solo accesible en ese bloque y

Tipos de datos en C (depende del compilador C)

Type Size Representation Range values

 Modificadores de Tipos de datos en C

 const: Constante, se localizan en la memoria de programa

 register: Se solicita al compilador que la variable se localice en un registro del

 static: Preserva el valor de las variables locales. Le da privacidad a las

 Usar punteros para acceder a estructuras y uniones;

 Usar decrementos en los lazos “for”.

Puesta a uno o cero de bit(s), forma alternativa:

 SMALL: Todas las variables se almacenan en la memoria

 COMPACT: Las variables se almacenan en la memoria externa.

 LARGE: Todas las variables se almacenan en memoria externa

0xFFFF 0xFFFF 0x2F

DATA IDATA XDATA

#pragma SMALL C:0x2000 E4 CLR A

unsigned char miFuncion(unsigned char data param){ miFuncion:

unsigned char miFuncionL(unsigned char param) miFuncionL:

Permite declarar un entero positivo en el rango de 0 – 1

Permite redefinir posiciones por bit en la zona de los SFR

Fuente de Vector de Orden de Bandera de Limpiado por Bandera de Control de

Timer 0 OverFlow 0x000B 1 TF0 (TCON.5) Y ET0 (IE.1) PT0 (IP.1)

Timer 1 OverFlow 0x001B 3 TF1 (TCON.7) Y ET1 (IE.3) PT1 (IP.3)

sbit ……. /* Definiciones de variables tipo sbit o bit */

int ……. /* Definiciones de variables globales */

void inicializacion(void) { /* Definiciones de funciones*/

/* Función main (principal) */

inicializacion(); /* Llamado de funciones */

void MiRutServicioTimer0(void) interrupt 1 { /* Definiciones de rutinas de atención Interrupción */

sbit tecla = P3^0;

unsigned char duplicar(unsigned char x){

unsigned char sumoDos(unsigned char x){

void T0M1Delay(void){ void T0M2Delay(void){ void Timer0Init(void){

void main(void){ void main(void){

void main(void){ void serial0() interrupt 4 {

# LED on Binario P1 Hex

Nota Frecuencia Periodo N veces 50us

 Escribir un programa en C para 8051 que envíe los valores 0-9 en

 Escribir un programa en C para 8051 que envíe los valores 00-99 en

Operator Name Syntax

Operator Name Syntax

 Operadores de bits en variables:

Operator Name Syntax

 Bit shifts: Rotación izquierda

 Bit shifts: Rotación a la derecha (con carry)