10 introduccion al lenguaje c 2.pdf

José Fernando Perez

INTRODUCCIÓN A LA PROGRAMACIÓN EN

LENGUAJE C DE MICROCONTROLADORES PIC

UTILIZANDO EL COMPILADOR C CCS Y EL

SIMULADOR PROTEUS

TIPOS DE LENGUAJES DE

PROGRAMACIÓN

José Fernando Perez

Lenguajes de

Alto nivel

Lenguaje

ensamblador

Lenguaje de

maquina

Lenguaje C.

Basic.Nemónicos

ASMCódigo Binario

Estructura de un programa

Directivas de Preprocesado: controlan la conversión del programa a

código maquina por parte del compilador.

•Programas o Funciones: conjunto de instrucciones. Pueden haber

uno o varios; en cualquier caso siempre debe haber uno definido

como principal mediante la inclusión de la llamada main().

•Instrucciones: indican como se debe comportar el PIC en todo

momento.

•Comentarios: permiten describir lo que significa cada línea de

programa.

Para escribir un programa en c con el compilador CCS C se deben tener

En cuenta una serie de elementos básicos de sus estructura.

Estructura de un programa

Directivas de preprocesado

Función Secundaria

Función Principal

Comentarios

Instrucciones

Tipo Tamaño Rango Descripción

Int1

1 bit 0 a 1Entero de 1 bit

Short

Int

8 bits 0 a 255Entero

Int8

Int16

16 bits 0 a 65535Entero de 16 bits

Long

Int 32 32 bits 0 a 4.249.967.295 Entero de 32 bits

Float 32 bits Coma flotante

Char 8 bits 0 a 255 Carácter

Void - - Sin valor

Signed Int8 8 bits -128 a + 127 Entero con signo

Signed Int16 16 bits -32768a + 32767 Entero Largo con signo

Signed Int32 32 bits Entero 32 bit con signo

Tipos de Datos

35 Decimal

O43 Octal(O)

0x23 Hexadecimal(0x)

0b00100011 Binario(0b)

‘x' Carácter

Int8 127U

Long 80UL

Signed INT16 80LFloat 3.14F

Char Con comillas simples 'C'

\n Cambio de linea

\r Retorno de carro

\t tabulacion

\b Backspace

Las constantes

Las constantes se pueden especificar en decimal, octal, hexadecimal o en binario:

Además, se pueden definir constantes con un sufijo:

También se definen caracteres especiales, algunos como:

+= Asignación de suma (x+=y es lo mismo que x=x+y)

-= Asignación de resta (x-=y es lo mismo que x=x-y)

*= Asignación de multiplicación (x*=y es lo mismo que x=x*y)

/= Asignación de división (x/=y es lo mismo que x=x/y)

%= Asignación del resto de la división (x%=y es lo mismo que x=x%y)

<<= Asignación de desplazamiento a la izquierda (x<<=y es lo mismo que x=x<<y)

>>= Asignación de desplazamiento a la derecha (x>>=y es lo mismo que x=x>>y)

&= Asignación AND de bits (x&=y es lo mismo que x=x&y)

|= Asignación OR de bits (x|=y es lo mismo que x=x|y)

^= Asignación de OR EXCLUSIVA de bits (x^=y es lo mismo que x=x^y)

Operadores

Asignación

Operadores

Aritméticos

+ Suma- Resta* Multiplicación

/ División% Modulo, resto de una división entera

-- Decremento++ Incremento

sizeof Determina el tamaño, en bytes, de un operando

Operadores

Relacionales

Lógicos

< Menor que

> Mayor que>= Mayor igual que

<= Menor igual que== Igual

!= Distinto

! NOT

&& AND|| OR

~ Complemento a 1

& AND

^ OR EXCLUSIVA

| OR

>> Desplazamiento a derechas

<< Desplazamiento a izquierda

De bits

& direccion* Indireccion

-> Puntero a estructura

Punteros

Funciones.

Las funciones son bloques de sentencias; todas las sentencias se beben enmarcar dentro de las funciones. Al igual que las

variables, las funciones deben definirse antes de utilizarse.

Una función puede ser invocada desde una sentencia de otra función. Una función puede devolver un valor a la sentencia

que la ha llamado. El tipo de dato se indica en la definición de la función; en el caso de no indicarse nada se entiende que es

un int8 y en el caso de no devolver un valor se debe especificar el valor VOID. La función, además de devolver un valor,

puede recibir parámetros o argumentos.

Tipo_dato Nombre_Funcion (tipo param1, param2,…)

{

(sentencias);

}

float trunca (float a)

{

Float b;

b=0x23;

a=a-b;

a=a*100;

a=floor(a);

a=a*0.01;

a=b+a;

return(a);

}

Declaraciones de Control:

La declaraciones son usadas para controlar el proceso de ejecución del programa

if (expresion_1)

sentencia_1;

[else

sentencia_2;]

IF-ELSE: Sirve para tomar decisiones.

if (expresion_1)

sentencia_1;

[else if (expresion 2)

sentencia_2;]

[else

sentencia_3;]

Los elementos que se encuentran entre corchetes [] son opcionales

Primero se evalúa la EXPRESION y si es cierta (TRUE o 1) ejecuta

SENTENCIA_1, EN EL CASO CONTRARIO (false o 0) ejecuta la

SENTENCIA_2.

Puede anidarse los IF-ELSE dando lugar a los ELSEE-IF; esto permite

tomar decisiones múltiples.

En caso de que existan varias sentencias a

ejecutar cuando se cumpla la condición se

deben utilizar llaves {}:

If (expresion)

{

Sentencia_1;

Sentencia_2;

:

Sentencia_n;

}

[else

{

sentencia_1;

:

Sentencia_n;

:

}]

Ejemplo 1:

If (A==0)

B=10;

Else

C=5;

If (A!=0)

C=5;

Else

B=10;

Forma 1 Forma 2

Ejemplo 2:

If (A>10)

{

if(A>20)

B=5;

else

B=15;

}

Ejemplo 3:

If (A>10)

{

if(A>20)

B=15;

}

Else

B=5;

switch (expresion_1)

{

Case constante 1:

sentencias;

Break;

Case constante 2:

Sentencias;

Break;

:

:

[default:

Sentecnias:]

}

SWITCH:

Sirve en caso particular de una decision multiple

Evalúa la expresión y en orden a la CONSTANTE adecuada realiza las sentencias

asociadas. Sin ninguno de los CASE corresponde a la CONSTANTE se ejecuta

DEFAULT (este comando es opcional).

El comando BREAK provoca la salida de SWITCH, de lo contrario se ejecuta el

siguiente CASE

Nota : No puede existir dos CASE con la misma CONSTANTE

switch (A)

{

Case 0:

B=1;

Break;

Case 2:

B=2;

Break;

Case 3:

B=3;

Break;

default:

Break;

}

Ejemplo :

For (inicializacion; condicion de finalizacion; incremento)

{

Sentencias ;

}

FOR:

Se usa para repetir sentencias En las expresiones del FOR la inicialización es una variable a la

cual se le asigna un valor inicial con el que controlar un bucle. La

condición de finalización sirve para evaluar ANTES de ejecutar

las sentencias si es cierta o no, en el caso de ser cierta se ejecutan

las sentencias y en caso contrario se sale del FOR. Por ultimo, la

expresión de incremento o decremento modifica la variable de

control DESPUES de ejecutar el bucle.

Nota : se pueden anidar bucles FOR utilizando distintas variables

de control.

Si se ejecuta la siguiente expresión se consigue un

BUCLE SIN FIN:

For (;;)

{

Sentencias;

}

Ejemplo :

For (N=1; N<=10; N++)

{

Printf (“%u”,N);

}

While (expresion)

{

Sentencias ;

}

WHILE:

Se usa para repetir sentencias

La expresión se evalúa y la sentencia se ejecuta mientras la

expresión es verdadera, cuando es falsa se sale del WHILE.

Si se ejecuta la siguiente expresión se consigue un

BUCLE SIN FIN:

WHILE (1)

{

Sentencias;

}

Ejemplo :

While (N>5 && M<10)

{

A=1;

B=2;

}

DO

{

Sentencias ;

}

While (expresion)

DO -WHILE:

Se diferencia del WHILE y del FOR en la condición de

finalización, la cual se evalúa al final del bucle, por lo que

Las sentencias se ejecutan al menos una vez

Si se ejecuta la siguiente expresión se

consigue un BUCLE SIN FIN:

DO

{

Sentencias;

}

WHILE (1);

Ejemplo :DO

{

A=1;

B=2;

}

While (N>5 && M<10);

Comentarios

Los comentarios en el programa facilitan la comprensión de las distintas expresiones tanto

para el programador como para quien tiene que interpretar dicho programa.

No afecta a la compilación por lo que pueden ser tan extensos como el programador quiera.

Se puede colocar en cualquier parte del programa y con dos formatos:

Utilizando //. Al colocar estos signos se comienza el comentario y finaliza en el final línea.

// comentario que termina al final de lalinea

Utilizando /* y */. Se debe utilizar y al final de comentario, pero no pueden repetirse

dentro del mismo comentario.

/*Este comentario no finaliza al final de la línea

Finaliza cuando se cierre el comentario */

GESTION DE PUERTOS EN C

En lenguaje C se pueden gestionar los puertos de dos formas:

•Se declaran los registros TRISX y PORTX definiendo su posición en la memoria RAM

como variables de C.

•Utilizando las directivas especificas del compilador (#USE FAST_IO, #USE FIXED_IO,

#USE STANDARD_IO).

Gestionando Puertos A través de 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 utilizada de C 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 85h

#BYTE TRISC = 0x87 // Variable TRISC en 87h

#BYTE PORTC = 0x07 // Variable PORTC en 07h

Una vez definidas estas variables se pueden configurar y controlar los puertos a

través de los comandos de asignación.

TRISB = 0xFF; //Configuración de 8 pines del PORTB como entrada

TRISC = 0x00; //Configuración de 8 pines del PORTC como salida

TRISD = 0x0F; //Configuración del PORTD con el nible alto como salida y el nible bajo como

// entrada. (nota: nible = 4 bits)

Escritura en los puertos:

PORTC = 0x0A; //salida de datos 00001010 por PORTA,

Lectura de puertos:

Valor = PORTB; // almacena en la variable valor el dato leído por el PORTB

Existen unas funciones de C que permiten manipular bit a bit los registros o

variables definidas previamente. Estas funciones son las siguientes:

Bit_clear(variable,bit); //Pone en 0 el bit especifico (0 a 7) de la variable.

Bit_set(variable,bit); //Pone en 1 el bit especifico (0 a 7) de la variable.

Bit_test(var,bit); //Muestrea el bit especifico (0 a 7) de la variable.

Swap(var); //Intercambia los 4 bits de mayor perso por los 4 de menor peso.

#include <16f877.h>

#fuses XT,NOWDT

#use delay(clock = 4000000)

#use fast_io(B)

#use fast_io(C)

#use fast_io(D)

void Main ()

{

output_B(0x00);

set_tris_B(0x00);

set_tris_D(0x00);

set_tris_C(0xff);

while(1)

{

if(input(PIN_C0) == 1)

{

output_high(PIN_B3);

}

else

{

output_low(PIN_B3);

}

if(input(PIN_C4)==1)

{

output_high(PIN_B7);

}

else

{

output_low(PIN_B7);

}

output_D(0x33)

}

}

Ejemplo:

bit_set (PORTC,4); //pone un 1 en el bit 4 del PORTC

If (bit_test(PORTB,0)==1) //Si el bit 0 del PORTB es igual a 1 poner un 0 en el bit 1 del

bit_clear(PORTD,1); //PORTD

Se puede declarar el bit de un registro con una variable mediante la directiva #BIT, lo que permite

trabajar directamente con la terminal:

#BIT nombre = posicion.bit

Ejemplo:

#BIT RB4 = 0x06.4 // Se define la variable RB4 como el bit 4 del PORTB

// teniendo en cuenta que el POTRB se encuentra en la dirección 0x06

RB4 = 1; // Se escribe en el bit 4 del PORTB un 1

Aplicacion1: Escribir un programa que capture datos del Puerto B, y los

Visualice por el Puerto D.

#INCLUDE <16F877.H>

#fuses XT,NOWDT

#byte TRISB = 0X86 //Definición de las posiciones

#byte TRISD = 0X87 //de memoria en las que se encuentran

#byte PORTD = 0X08 //los registros

#byte PORTB = 0X06

void main()

{

TRISB = 0x00; //Configuración PORTB como salida

while(1) // Ciclo infinito

{

PORTB = PORTD; //Lectura del PORTD y visualización en

//PORTB

}

}

Gestionando Puertos A través de las directivas

El compilador ofrece funciones predefinidas para trabajar con los puertos. Estas funciones

son:

output_X(valor); //Por el puerto correspondiente 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 pull-up en PORTB

get_trisX(); //Devuelve el valor del registro TRISx

Donde X es la inicial del puerto correspondiente (A,B,C,…).

Ejemplos:

output_D(0xFF); //saca por el puerto D el valor 1111 1111

X=Input_B(); //lee el valor del puerto B y lo guarda en la variable X

Set_tris_C(0x0f); //configura el puerto C como salida en el nible alto

// y entrada en el nible bajo

Existen una serie de funciones asociadas a un determinado pin* . El parámetro pin* se define en un fichero

include (por ejemplo, 16f877.h) con un formato del tipo PIN_Xn, donde X es el puntero y n es el numero del pin.

#define PIN_A0 40

#define PIN_A1 41

Las funciones son :

output_low(pin*); //Pin a 0

output_high(pin*); //Pin a 1.

output_bit(pin*,valor ); //Pin al valor especificado.

output_toggle(pin*); //complementar el valor del pin

output_float(pin*); //Pin de entrada, quedando a tensión flotante…

//(simula salida en drenador abierto)

input_state(pin*); //Lee el valor del pin sin cambiar el sentido del terminal

input(pin*); //lee el valor del pin

Las funciones output_x() e input_x() dependen de la directiva tipo #USE*_IO que este activa.

DIECTIVAS

#USE_FAST_IO(PUERTO)

Con la funcion output_x()se saca el valor al puerto y con la funcion input_x() se lee el puerto. La directiva no modifica previamente el registro TRIS

correpondiente. Hay que asegurarse de que los registros TRIS estan correctamente definidos. Entonces, la aplicación 1 se puede escribir de la

siguiente forma:

#INCLUDE <16F877.H>

#fuses XT,NOWDT


#use fast_io(B)

#use fast_io(D)

void main()

{

port_b_pullups(TRUE); //se habilitan las resistencias Pull ups del PORTB

set_tris_B(0x00); //se configura el PORTB como salida

output_B(0x000); // se inicia el PORTB con 00H

while(1) //Ciclo infinito

{

output_B(input_D()); //se lee el contenido el PORTD y se saca por PORTB

}

}

…..DIECTIVAS

#USE_STANDARD_IO(PUERTO)

Con la función output_x() el compilador se asegura de que el terminal, o terminales correspondientes, sean de salida mediante la modificación del

TRIS correspondiente- correspondientes. Con la función input _x() ocurre lo mismo pero asegurando el terminal(terminales) como entrada. Es la

directiva por defecto. Entonces la aplicación 1 queda de la siguiente forma:

#INCLUDE <16F877.H>

#fuses XT,NOWDT


#use standard_io(B)

#use standard_io(D)

void main()

{





{


}

}

…..DIRECTIVAS

#USE_FIXED_IO(PUERTO_OUTPUTS=pin*,…)

Con la función output_x() el compilador se asegura de que el terminal, o terminales correspondientes, sean de salida mediante la modificación del

TRIS correspondiente- correspondientes. Con la función input _x() ocurre lo mismo pero asegurando el terminal(terminales) como entrada. Es la

directiva por defecto. Entonces la aplicación 1 queda de la siguiente forma:

Pendiente …..

#INCLUDE <16F877.H>

#fuses XT,NOWDT


#use fixed_io(B)

#use fast_io(D)

void main()

{





{


}

}

Aplicación 2. Visualización usando display 7 Segmentos

Realizar la decodificación del dato capturado por el PORTA y mostrarlo en un display

7 segmentos conectado en el PORTB.


#include <16F877.h>

#byte PORTB = 0X06 /* dirección del puerto B */

#byte PORTA = 0X05

#byte TRISA = 0X85 /* dirección del puerto B */

#byte TRISB = 0X86

BYTE CONST DISPLAY[16] = {64,121,36,48,25,18,3,120,0,24,8,3,70,33,6,14};

//tabla de los valores correspondientes en 7 segmentos

INT PUNTERO;

setup_adc_ports( NONE ); //configura el PORTA como digital

void main() {

TRISB = 0X00; //Configura puerto B como salida

do{

PUNTERO = PORTA; // Lee el puerto A

PUNTERO = PUNTERO&0X0F; // Borra la parte alta de puntero

PORTB = DISPLAY[PUNTERO]; // muestra en el Puerto B el código 7 segmentos respectivo

}

while (TRUE) ;

}


Realizar un contador de 0 a 99 con un display de 7 segmentos de cátodo común.


#include <16F876.h>

#USE DELAY( CLOCK=4000000)

#byte PORTB = 0X06 /* dirección del puerto B */

#byte PORTA = 0X05

#byte TRISA = 0X85 /* dirección del puerto B */

#byte TRISB = 0X86

byte CONST DISPLAY[10] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};

setup_adc_ports( NONE ); //configura el PORTA como digital

main(){

byte ud=0,dec=0;

TRISB = 0X00;

TRISA = 0X00;

for( ;; ){

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

{ //Cuenta digito decenas

for (ud=0;ud<10;ud++){

PORTA=0X02; //cat_D=apagado,cat_U=encendido

PORTB = DISPLAY[ud]; //Digito unidades

delay_ms(50); //Para evitar parpadeos

if (dec==0)

PORTA =0x03; //Si decenas=0, cat_D=apagado

else //Si decenas>0, cat_D=encendido

PORTB =DISPLAY[dec]; //Digito decenas


}

}

}

}


#include <16F876.h>

#USE DELAY( CLOCK=4000000)

#FUSES XT,NOWDT,NOPROTECT,NOPUT

#USE fast_IO (B)

#USE fast_IO (A)

byte CONST DISPLAY[10] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};

main(){

byte ud=0,dec=0;

SET_TRIS_B(0x00);

SET_TRIS_A(0x00);

OUTPUT_B(0);

for( ;; ){

for (dec=0;dec<10;dec++){ //Cuenta digito decenas

for (ud=0;ud<10;ud++){

OUTPUT_A(0x02); //cat_D=apagado,cat_U=encendido

OUTPUT_B(DISPLAY[ud]); //Digito unidades


if (dec==0) OUTPUT_A(0x03); //Si decenas=0, cat_D=apagado

else OUTPUT_A(0x01); //Si decenas>0, cat_D=encendido

OUTPUT_B(DISPLAY[dec]); //Digito decenas


}

}

}

}

Planteamiento

Se quiere controlar un motor Paso a Paso unipolar con el

circuito de la figura según los siguientes parámetros:

a) Con la parte baja del puerto D se programa el numero de

vueltas a dar por el motor.

b) Con l pin RC0 se determina el sentido de giro.

c) Con el pin RC1 se inicia el movimiento de acuerdo a lo

programado en los ítems a y b.

Nota : Suponga que el motor gira 10 grados por cada Paso a

una velocidad constante determinada a su criterio.

Problema 1. Control de un motor Paso a Paso unipolar

1 Vss Tierra

2 Vdd Alimentación +5V

3 Vo Ajuste de Voltaje de Contraste

Selección Datos/Control

Rs = 0 à Control

Rs = 1 à Datos

Lectura/Escritura

R/W = 0 à Escritura

R/W = 1 à Lectura

Habilitación

E= 0 deshabilita

E= 1 habilita

7 D0

8 D1

9 D2

10 D3

11 D4

12 D5

13 D6

14 D7

BUS DE PALABRA DE DATOS

6 E

4 RS

5 R/W

LCD - Display de Cristal Liquido

El compilador C incluye un fichero (driver ) que permite trabajar con un LCD . El archivo es LCD.c y debe llamarse de la

siguiente forma :

#include <lcd.c>

Este archivo dispone de varias funciones ya definidas:

lcd_init();

Es la primera función que debe ser llamada. Y contiene la siguiente secuencia de inicialización:

Bus a 4 bits, dos líneas caracteres 5x8

Lcd encendido, Cursor Apagado y sin parpadeo

Incrementar cursor, sin desplazamiento .

Lcd_gotoxy(byte x, byte x);

Indica la posición de acceso al LCD. Por ejemplo, (1,1) indica la primera posición de la primer línea y (1,2) indica la primer

posición de la segunda línea.

Lcd_getc(byte x. byte x);

Lee el carácter de la posición (x,y).

Lcd_putc(char s);

S es una variable de tipo char . Esta función escribe la variable en la posición correspondiente.

lcd_send_byte( RS, n )

RS: es 0 si lo enviado es para configurar el LCD

RS: es 1 si lo enviado es para mostrar un carácter

N: es un byte de 8 bits que representa la palabra de configuración o el código ASCII del carácter.

#include <16F877.h>

#fuses HS,NOWDT,NOPROTECT,NOLVP

#use delay(clock=20000000)

#define use_portd_lcd_TRUE //configura LCD para trabajar usando PORTD

#include <lcd.c>

void main()

{

lcd_send_byte(0, 0x02 ); //secuencia de

lcd_send_byte(0, 0x28 ); //inicialización del

lcd_send_byte(0, 0x06 ); //LCD

lcd_send_byte(0, 0x0C );

lcd_send_byte(0, 0x01 );

lcd_send_byte(1, 0x41 ); //Envía el carácter A

Lcd_putc("EIOU"); //Envía los caracteres

//EIOU

while(1)

{ //CICLO INFINITO

}

}

Aplicación 4. Visualización usando display de cristal Liquido

El siguiente programa envía los caracteres AEIOU usando las funciones

lcd_send_byte() y lcd_putc() :

Aplicación 4. Visualización usando display de cristal Liquido

El siguiente programa envía los caracteres AEIOU usando las funciones

lcd_init(), lcd_send_byte() y lcd_putc() :

#include <16F877.h>

#fuses HS,NOWDT,NOPROTECT,NOLVP

#use delay(clock=20000000)

#define use_portd_lcd_TRUE //CONFIGURA LCD PARA TRABAJAR EL LCD USANDO

#include <lcd.c> //PORTD

void main()

{

lcd_init(); //se genera la secuencia de inicialización

//del LCD

lcd_send_byte(1, 0x41 ); //Envía el carácter A

Lcd_putc("EIOU"); //Envía los caracteres

//EIOU

while(1)

{ //CICLO INFINITO

}

}

CONTROL DEL LCD USANDO PRINTF

El compilador C ofrece una función mas versátil para trabajar el LCD denominada printf()

Printf(string)

Printf(cstring, values…)

Printf(fname, cstring, values …)

Donde:

String : es una cadena o arreglo de caracteres

values: es una lista de variables separadas por comas

fname : es una función.

Ejemplo 1:

Int z;

z= 0x89;

Printf(lcd_putc,“Temperatura: %2x\n\r”,z);

%2x = 2 caracteres tipo entero hexadecimal

\n = el cursor va a la posicion (1,2) primera posicion de la segunda linea

\r = deja un espacio

Ejemplo 2:

Int z;

z= 0x89;

Printf(lcd_putc,“Temperatura: %2u\n\r”,z);

%2u = 2 caracteres tipo entero decimal

\n = el cursor va a la posicion (1,2) primera posicion de la segunda linea


Ejemplo 3:

float z;

z= 0x89;

Printf(lcd_putc,“Temp: %.3f\n\r”,z);

%.3f = muestre el valor de tipo float con 3 decimales

\n = el cursor va a la posición (1,2) primera posición de la segunda línea


Formato %nt

%n es opcional y especifica el numero de caracteres a mostrar:

1-9: para especificar cuantos caracteres se deben mostrar

01-09: para especificar la cantidad de ceros a la izquierda

1.1 – 9.9: para como flotante

Int z;

z= 0x9;

Printf(lcd_putc,“Temperatura: %03u\n\r”,z);

%03u = muestre el valor de tipo entero con 3 dígitos

\n = el cursor va a la posición (1,2) primera posición de la segunda línea


Formato %nt

t indica:

c Carácter

s Cadena o carácter

u Entero sin signo

d Entero Con signo

Lu Entero Largo sin signo

Ld Entero Largo con signo

x Entero Hexadecimal(minuscula)

X Entero Hexadecimal (Mayúscula)

Lx Entero Largo Hexadecimal(minuscula)

LX Entero Largo Hexadecimal (Mayúscula)

f Flotante con truncado

g Flotante con redondeo

e Flotante con formato exponencial

10 introduccion al lenguaje c 2.pdf

Documents