Download - 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 delay(clock = 4000000)
#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 delay(clock = 4000000)
#use standard_io(B)
#use standard_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
}
}
…..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 delay(clock = 4000000)
#use fixed_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
}
}
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.
Aplicación 2. Visualización usando display 7 Segmentos
#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) ;
}
Aplicación 3. Visualización usando display 7 Segmentos
Realizar un contador de 0 a 99 con un display de 7 segmentos de cátodo común.
Aplicación 3. Visualización usando display 7 Segmentos
#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
delay_ms(50); //Para evitar parpadeos
}
}
}
}
Aplicación 3. Visualización usando display 7 Segmentos
#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
delay_ms(50); //Para evitar parpadeos
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
delay_ms(50); //Para evitar parpadeos
}
}
}
}
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
\r = deja un espacio
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
\r = deja un espacio
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
\r = deja un espacio
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