MPLAB C18: Librerias ANSI C

Rev: 1.0

Omar Gurrola

http://www.proprojects.wordpress.com

7/24/2012

MPLAB C18: Librerías ANSI C

Omar Gurrola MPLAB C18: Librerías ANSI C http://www.proprojects.wordpress.com

Revisión: 1.0 [07/2012]

CONTENIDO

LICENCIA ............................................................................................................................................1

AGRADECIMIENTOS ...........................................................................................................................2

INTRODUCCIÓN .................................................................................................................................2

OBJETIVO DE ESTE TUTORIAL..............................................................................................................2

SOFTWARE Y HARDWARE UTILIZADO .................................................................................................2

1. Librería <assert.h> ......................................................................................................................3

1.1. Ejemplo con <assert.h> ................................................................................................................. 3

2. Librería <ctype.h> .......................................................................................................................5

2.1. Ejemplo con <ctype.h> .................................................................................................................. 5

3. Librería <errno.h> .......................................................................................................................7

4. Librería <float.h> ........................................................................................................................8

5. Librería <limits.h> ..................................................................................................................... 10

6. Librería <locale.h> .................................................................................................................... 11

7. Librería <math.h> ..................................................................................................................... 11

7.1. Ejemplo con <math.h> ................................................................................................................ 12

8. Librería <setjmp.h> ................................................................................................................... 14

8.1. Ejemplo con < setjmp.h>............................................................................................................. 14

9. Librería <signal.h> .................................................................................................................... 15

10. Librería <stdarg.h> .................................................................................................................... 15

10.1. Ejemplo con <stdarg.h> .......................................................................................................... 15

11. Librería <stddef.h>.................................................................................................................... 17

11.1. Ejemplo con <stddef.h> .......................................................................................................... 17

12. Librería <stdio.h> ...................................................................................................................... 19

12.1. Ejemplo con <stdio.h> ............................................................................................................. 20

13. Librería <stdlib.h> ..................................................................................................................... 26

13.1. Ejemplo con <stdlib.h> ............................................................................................................ 26

14. Librería <string.h> ..................................................................................................................... 30

14.1. Ejemplo con <string.h> ........................................................................................................... 32

15. Librería <timer.h> ..................................................................................................................... 42

16. Librería <delays.h> ................................................................................................................... 42


Revisión: 1.0 [07/2012]

16.1. Ejemplo con <delays.h> .......................................................................................................... 42

17. Librería <reset.h> ..................................................................................................................... 44

18. Tabla ASCII ............................................................................................................................... 45

19. REFERENCIAS ............................................................................................................................ 46


Revisión: 1.0 [07/2012] 1

LICENCIA

MPLAB C18: Librerías ANSI C por Omar Gurrola – http://www.proprojects.wordpress.com se encuentra bajo una

Licencia Creative Commons Atribución-NoComercial-CompartirIgual 3.0 Unported.

http://www.proprojects.wordpress.com/

http://creativecommons.org/licenses/by-nc-sa/3.0/

http://creativecommons.org/licenses/by-nc-sa/3.0/


Revisión: 1.0 [07/2012] 2

AGRADECIMIENTOS

Gracias a mi esposa Tomiko, por ser mí apoyo y empujarme a seguir adelante.

A todas las personas que han dedicado tiempo y esfuerzo a realizar tutoriales y/o guías.

INTRODUCCIÓN

En esta ocasión realizaremos algunos ejercicios utilizando las librerías ANSI C en el compilador MPLAB C18 de

Microchip.

OBJETIVO DE ESTE TUTORIAL

El objetivo es aprender a utilizar las librerías estándar de C (ANSI C) para utilizarlas en los proyectos que se

desarrollen más delante.

SOFTWARE Y HARDWARE UTILIZADO

Todas las prácticas fueron desarrolladas y probadas con:

Software:

Windows 7 SP1 x64

Microchip MPLAB IDE v8.84

Microchip C18 3.4

Hardware:

AMD Phenom II 9600B Quad-Core 2.3 GHz

4GB DDR2


Revisión: 1.0 [07/2012] 3

1. Librería <assert.h>

Esta librería se utiliza para realizar pruebas y buscar errores durante la ejecución del programa.

La librería consta de:

Tipo: Nombre: Descripción:

Macro void assert(int test); Comprueba la condición “test” y si el resultado es falso (o cero) el programa aborta mandando el mensaje “condición, fichero, numero de línea” a la salida estándar.

Directiva #define NDEBUG Si se coloca antes de #include <assert.h> todas las sentencias de assert() son ignoradas.

Lamentablemente esta librería no está implementada en MPLAB C18, pero eso no impedirá que podamos

implementar una muy similar.

Como esta librería manda el mensaje por la salida estándar tenemos que mostrar el mensaje en alguna ventana

durante su ejecución. Se puede utilizar la ventana de salida del “SIM uart” y para configurarlo realiza lo siguiente:

1. Para activar el simulador: Debuger >> Select Tool >> MPLAB SIM

2. Para activar el uart1: Debugger >> Settings… >> Uart1 IO >> Enable Uart1 IO=true y Output=Window

1.1. Ejemplo con <assert.h>

assert.h

/********************************************************************* * By: Omar Gurrola * Company: http://www.proprojects.wordpress.com * Processor: PIC18 * Compiler: C18 3.4 * File Name: assert.h * Description: * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Rev. Date Comment * 1.0 05/29/12 Initial version ********************************************************************/ #ifndef __ASSERT_H #define __ASSERT_H /** INCLUDES *******************************************************/


Revisión: 1.0 [07/2012] 4

#include <stdio.h> /** MACROS & TYPEDEF ***********************************************/ #ifndef NDEBUG #define assert(test) _assert(test, __LINE__, __FILE__) #else #define assert(test) ; #endif /** PROTOTYPES *****************************************************/ void _assert (unsigned char test, unsigned int linenumber, const far rom char* filename){ if (!test){ printf ("Assertion failed: file %HS, line %d\n", filename, linenumber); #ifdef __DEBUG //{_asm HALT _endasm} #else //{_asm RESET _endasm} #endif } } #endif // __ASSERT_H

main.c

/* * Autor: Omar Gurrola * Date: 05/29/12 * Site: http://www.proprojects.wordpress.com * * File: main.c * Program: MPLAB C18: Librerías ANSI C * Description: 1.1. Ejemplo con <assert.h> */ //#define NDEBUG #include "assert.h" void main(void) { // Condiciones donde assert se cumple assert(1); // No mensaje assert(5>2); // No mensaje assert(4==4); // No mensaje // Condiciones donde assert no se cumple assert(0); // Assertion failed: file main.c, line 45 assert(5<2); // Assertion failed: file main.c, line 46 assert(3==2); // Assertion failed: file main.c, line 47 }


Revisión: 1.0 [07/2012] 5

2. Librería <ctype.h>

Esta librería se utiliza para convertir y verificar caracteres. La tabla ASCII viene anexada en el ultimo capitulo de

este documento.


Tipo: Nombre: Descripción: Rango: Cantidad:

Función int tolower(int); Convierte un carácter a minúscula (a-z) => (A-Z) 26 Función int toupper(int); Convierte un carácter a mayúscula (A-Z) => (a-z) 26 Función int isalnum(int); Si el carácter es alfanumérico regresa verdadero (a-z), (A-Z), (0-9) 62 Función int isalpha(int);; Si el carácter es una letra regresa verdadero (a-z), (A-Z) 52 Función int iscntrl(int); Si el carácter es un control regresa verdadero (0x00-0x1F), 0x7F 33 Función int isdigit(int); Si el carácter es un digito regresa verdadero (0-9) 10 Función int isgraph(int); Si el carácter es imprimible regresa verdadero (0x21-0x7E) 94 Función int islower(int); Si el carácter está en minúscula regresa verdadero (a-z) 26 Función int isprint(int); Si el carácter es imprimible regresa verdadero (0x20-0x7E) 95

Función int ispunct(int); Si el carácter es de puntuación regresa verdadero (0x21-0x29), (0x2A-0x2F), (0x3A-0x40), (0x5B-0x60),

(0x7B-x7F), 0x80 32

Función int isspace(int); Si el carácter es un espacio regresa verdadero 0x09, (0x0A-0x0D), 0x20 6 Función int isupper(int); Si el carácter esta en mayúscula regresa verdadero (A-Z) 26 Función int isxdigit(int); Si el carácter es hexadecimal regresa verdadero (0-9), (A-F), (a-f) 22

2.1. Ejemplo con <ctype.h>

main.c

/* * Autor: Omar Gurrola * Date: 05/29/12 * Site: http://www.proprojects.wordpress.com * * File: main.c * Program: MPLAB C18: Librerías ANSI C * Description: 2.1. Ejemplo con <ctype.h> */ #include <ctype.h> void main(void) { char c[8]; unsigned char ascii; unsigned char AlphaNumerics = 0; unsigned char Letters = 0; unsigned char Controls = 0; unsigned char Digits = 0; unsigned char Graphs = 0; unsigned char Lowers = 0; unsigned char Prints = 0; unsigned char Punctuations = 0; unsigned char Spaces = 0; unsigned char Uppers = 0; unsigned char Hexadecimals = 0; // Convierte a minuscula c[0] = tolower('A'); // a c[1] = tolower('B'); // b c[2] = tolower('c'); // Se queda igual c[3] = tolower('&'); // Se queda igual // Convierte a mayuscula


Revisión: 1.0 [07/2012] 6

c[4] = toupper('d'); // D c[5] = toupper('e'); // E c[6] = toupper('F'); // Se queda igual c[7] = toupper('^'); // Se queda igual // Evaluamos toda la tabla ASCII (0-127) // y obtenemos el total de cada tipo de caracter for(ascii=0; ascii<128; ascii++){ if(isalnum(ascii)) AlphaNumerics++; if(isalpha(ascii)) Letters++; if(iscntrl(ascii)) Controls++; if(isdigit(ascii)) Digits++; if(isgraph(ascii)) Graphs++; if(islower(ascii)) Lowers++; if(isprint(ascii)) Prints++; if (ispunct(ascii)) Punctuations++; if (isspace(ascii)) Spaces++; if (isupper(ascii)) Uppers++; if (isxdigit(ascii)) Hexadecimals++; } }


Revisión: 1.0 [07/2012] 7

3. Librería <errno.h>

Esta librería la utilizan otras librerías para administrar errores.



Macro EDOM Su valor representa un error de dominio que regresan algunas funciones matemáticas Macro ERANGE Su valor representa un error de rango que regresan algunas funciones matemáticas

Variable int errno Vale cero al principio del programa, si ocurre un error este numero se asigna a errno

errno.h

/* errno.h standard header */ #ifndef _ERRNO #define _ERRNO /* ERROR CODES */ #define EDOM 33 #define ERANGE 34 /* DECLARATIONS */ extern int errno; #endif


Revisión: 1.0 [07/2012] 8

4. Librería <float.h>

Esta librería define los límites máximos y mínimos de variables flotantes y dobles.


Tipo: Nombre: Descripción: Valor en C18:

Macro FLT_ROUNDS

Define como se redondean los números flotantes: -1 Indefinido 0 A cero 1 Al más cercano 2 Hacia el infinito positive 3 Hacia el infinito negativo

Este valor está definido por el compilador

0

Macro FLT_RADIX Define la base con la que se representan los exponentes. (base 2 - binario, base 10 - decimal, base 16 - hexadecimal)

2

Macro FLT_MANT_DIG DBL_MANT_DIG LDBL_MANT_DIG

Define el número de dígitos 23 Macro Macro Macro FLT_DIG

DBL_DIG LDBL_DIG

Define el número de dígitos decimales que se representaran sin redondear En C18 está definido como: #define DECIMAL_DIG

17 Macro Macro Macro FLT_MIN_EXP

DBL_MIN_EXP LDBL_MIN_EXP

Define el valor mínimo negativo para un exponente en base FLT_RADIX

-126 Macro Macro Macro FLT_MIN_10_EXP

DBL_MIN_10_EXP LDBL_MIN_10_EXP

Define el valor mínimo negativo para un exponente en base 10

-37 Macro Macro Macro FLT_MAX_EXP

DBL_MAX_EXP LDBL_MAX_EXP

Define el valor máximo positivo para un exponente en base FLT_RADIX

128 Macro Macro Macro FLT_MAX_10_EXP

DBL_MAX_10_EXP LDBL_MAX_10_EXP

Define el valor máximo positivo para un exponente en base 10

38 Macro Macro Macro FLT_MAX

DBL_MAX LDBL_MAX

Valor máximo en punto decimal 1.17549435E-38 Macro Macro Macro FLT_EPSILON

DBL_EPSILON LDBL_EPSILON

Digito menos significativo presentable 1.19209290E-07 Macro Macro Macro FLT_MIN

DBL_MIN LDBL_MIN

Valor mínimo en punto decimal 6.80564693E+38 Macro Macro float.h

/* * float.h * * Defines implementation specific limits on type values. * * Copyright (c) 2002, Microchip Technology Inc. * 2355 W.Chandler Blvd., Chandler, AZ, 85224 * All Rights Reserved. */ #ifndef __FLOAT_H #define __FLOAT_H


Revisión: 1.0 [07/2012] 9

/* C18 rounds toward zero */ #define FLT_ROUNDS 0 /* C18 does all floating point computation at range and precision of float type*/ #define FLT_EVAL 0 #define FLT_RADIX 2 #define FLT_MANT_DIG 23 #define DECIMAL_DIG 17 #define FLT_MIN_EXP -126 #define FLT_MAX_EXP 128 #define FLT_MIN_10_EXP -37 #define FLT_MAX_10_EXP 38 #define FLT_MIN 1.17549435E-38 #define FLT_MAX 6.80564693E+38 #define FLT_EPSILON 1.19209290E-07 #define DBL_MANT_DIG FLT_MANT_DIG #define DBL_MIN_EXP FLT_MIN_EXP #define DBL_MAX_EXP FLT_MAX_EXP #define DBL_MIN_10_EXP FLT_MIN_10_EXP #define DBL_MAX_10_EXP FLT_MAX_10_EXP #define DBL_MIN FLT_MIN #define DBL_MAX FLT_MAX #define DBL_EPSILON FLT_EPSILON #define LDBL_MANT_DIG FLT_MANT_DIG #define LDBL_MIN_EXP FLT_MIN_EXP #define LDBL_MAX_EXP FLT_MAX_EXP #define LDBL_MIN_10_EXP FLT_MIN_10_EXP #define LDBL_MAX_10_EXP FLT_MAX_10_EXP #define LDBL_MIN FLT_MIN #define LDBL_MAX FLT_MAX #define LDBL_EPSILON FLT_EPSILON #ifdef __TRADITIONAL18__ extern near volatile struct { unsigned IOV:1; unsigned FOV:1; unsigned FUN:1; unsigned FDZ:1; unsigned NAN:1; unsigned DOM:1; unsigned RND:1; unsigned SAT:1; } __FPFLAGSbits; #endif #endif /* __FLOAT_H */


Revisión: 1.0 [07/2012] 10

5. Librería <limits.h>

Esta librería define los límites de cada tipo de variable que hay, excepto float y double.


Tipo: Nombre: Descripción: Valor en C18:

Macro CHAR_BIT Numero de bits en un byte 8 Macro SCHAR_MIN Valor mínimo para signed char -128 Macro SCHAR_MAX Valor máximo para signed char 127 Macro UCHAR_MAX Valor máximo para unsigned char 255 Macro CHAR_MIN Valor mínimo para char -128 Macro CHAR_MAX Valor máximo para char 127 Macro MB_LEN_MAX Numero máximo de bytes en un carácter multi-byte 2 Macro SHRT_MIN Valor mínimo para short -32768 Macro SHRT_MAX Valor máximo para short 32767 Macro USHRT_MAX Valor máximo para unsigned short 65535 Macro INT_MIN Valor mínimo para int -32768 Macro INT_MAX Valor máximo para int 32767 Macro UINT_MAX Valor máximo para unsigned int 65535 Macro LONG_MIN Valor mínimo para long 0x80000000 Macro LONG_MAX Valor máximo para long 0x7FFFFFFF Macro ULONG_MAX Valor máximo para unsigned long 0xFFFFFFFF

limits.h

#ifndef __LIMITS_H #define __LIMITS_H #define CHAR_BIT 8 /* number of bits in a char */ #define MB_LEN_MAX 2 /* max. # bytes in multibyte char */ #define SCHAR_MIN (-128) /* minimum signed char value */ #define SCHAR_MAX 127 /* maximum signed char value */ #define UCHAR_MAX 255 /* maximum unsigned char value */ /* changed '\x80' to 0x80 on the next line */ #if 0x80 < 0 /* signed chars ? */ #define CHAR_MIN SCHAR_MIN /* minimum char value */ #define CHAR_MAX SCHAR_MAX /* maximum char value */ #else /* unsigned chars */ #define CHAR_MIN 0 #define CHAR_MAX UCHAR_MAX #endif #define SHRT_MIN (-32767-1) /* minimum signed short value */ #define SHRT_MAX 32767 /* maximum signed short value */ #define USHRT_MAX 65535U /* maximum unsigned short value */ #define LONG_MIN 0x80000000 #define LONG_MAX 0x7fffffff #define ULONG_MAX 0xffffffff #define SLONG_MIN 0x800000 /* minimum signed short long value */ #define SLONG_MAX 0x7fffff /* maximum signed short long value */ #define USLONG_MAX 0xffffff /* maximum unsigned short long value */ /* Our ints are 16-bit just like our shorts */ #define INT_MIN SHRT_MIN /* minimum signed int value */ #define INT_MAX SHRT_MAX /* maximum signed int value */ #define UINT_MAX USHRT_MAX /* maximum unsigned int value */ /* alternate names for INT_MAX and INT_MIN */ #define MIN_INT INT_MIN #define MAX_INT INT_MAX #endif /* __LIMITS_H */


Revisión: 1.0 [07/2012] 11

6. Librería <locale.h>

Esta librería se utiliza para obtener o especificar información básica sobre la región o zona, esta librería afecta a

otras. En C18 no está implementada debido a que el hardware son microcontroladores.

7. Librería <math.h>

Esta librería contiene funciones para realizar operaciones matemáticas.


Tipo: Nombre: Categoría: Descripción:

Macro HUGE_VAL 6.3e38 Lo regresan las funciones siguientes cuando el resultado es demasiado grande para ser mostrado.

Función double acos(double x);

Funciones Trigonométricas

Regresa el arco coseno de x (-1 a +1) en radianes (0 a Pi)

Función double asin(double x); Regresa el arco seno de x (-1 a +1) en radianes (-Pi/2 a +Pi/2)

Función double atan(double x); Regresa el arco tangente de x en radianes (-Pi/2 a +Pi/2)

Función double atan2(double x, double y); Regresa el arco tangente de x/y (x & y ! = 0) en radianes (-Pi/2 a +Pi/2)

Función double cos(double x); Regresa el coseno de x (-1 a +1) en radianes Función double cosh(double x); Regresa el coseno hiperbólico de x en radianes Función double sin(double x); Regresa el seno de x en radianes (-1 a +1) Función double sinh(double x, double y); Regresa el seno hiperbólico de x en radianes Función double tan(double x); Regresa el tangente de x en radianes

Función double tanh(double x); Regresa el tangente hiperbólico de x en radianes (-1 a +1)

Función double exp(double x);

Exponenciales, Logarítmicos y Potencias

Regresa el valor de e a la x potencia

Función double frexp(double x, int *exponent);

Parte el número double en una fracción normalizada y un entero con potencia a la 2, regresa la mantisa (0.5 a 1). x = mantisa * 2^exponent

Función double ldexp(double x, int exponent); Regresa x multiplicado por 2^exponent Función double log(double x); Regresa el logaritmo natural de x Función double log10(double x); Regresa el logaritmo base 10 de x Función double modf(double x, double* integer); Parte el valor x en entero y decimal Función double pow(double x, double y); Regresa x elevado a la potencia y Función double sqrt(double x); Regresa la raíz cuadrada de x Función double ceil(double x);

Otras

Regresa el valor entero igual o mayor a x Función double fabs(double x); Regresa el valor absoluto de x Función double floor(double x); Regresa el valor entero igual o menor a x Función double fmod(double x, double y); Regresa el resto de dividir x / y


Revisión: 1.0 [07/2012] 12

7.1. Ejemplo con <math.h>

main.c

#include <math.h> void main() { double x,y,z; int ex; // Funciones Trigonométricas x = 1; // x (-1 a +1), z (0 a Pi) radianes z = acos(x); // z = 0 x = 0; // x (-1 a +1), z (-Pi/2 a +Pi/2) radianes z = asin(x); // z = 0 x = 0; // z (-Pi/2 a +Pi/2) radianes z = atan(x); // z = 0 x = 1; y = 2; // x / y, z (-Pi/2 a +Pi/2) radianes z = atan2(x,y); // z = 0.4636 x = 0; // z (-1 a +1) z = cos(x); // z = 1 x = 0; // z = cosh(x); // z = 1 x = 0; // z (-1 a +1) z = sin(x); // z = 0 x = 0; // z = sinh(x); // z = 0 x = 0; // z = tan(x); // z = 0 x = 0; // z (-1 a +1) z = tanh(x); // z = 0 // Funciones Exponenciales, Logarítmicos y de Potencias x = 1; // z = e^x z = exp(x); // z = 2.718282 x = 256; ex = 8; // x = z * 2^y, z (0.5 a 1), z = frexp(x,&ex); // z = 0.5, ex = 9 x = 1; y = 8; // z = x * 2^y z = ldexp(x,y); // z = 256 x = 2.718282; // z = log e (x) z = log(x); // z = 1 x = 1000; // z = log10(x); // z = 3 x = 3.1416; // z = Decimal, y = Entero z = modf(x,&y); // z = 0.14159, y = 3.0 x = 5; y = 2; // z = x ^ y z = pow(x,y); // z = 25 x = 16; // z = (x)^0.5 z = sqrt(x); // z = 4 // Otras x = 6.01; // ^ z = ceil(x); // z = 7 x = -55; // z = |x| z = fabs(x); // z = 55 x = 5.99; // V


Revisión: 1.0 [07/2012] 13

z = floor(x); // z = 5 x = 5; y = 2; // z = fmod(x,y); // z = 1 }


Revisión: 1.0 [07/2012] 14

8. Librería <setjmp.h>

Esta librería se utiliza para controlar llamadas y retornos a funciones en bajo nivel.



Macro int setjmp(jmp_buf entorno)

Guarda su entorno y llamada en el parámetro entorno, para que después sea utilizada por longjmp(). Si el valor regresado es diferente de cero entonces fue llamado con longjmp()

Variables void longjmp(jmp_buf entorno, int valor);

Provoca que brinque y se ejecute a partir de donde se guardó el entorno anteriormente. El valor que se le da lo regresara setjmp(), debe ser diferente de cero

Función typedef jmp_buf Es un arreglo que guarda información para setjmp() y longjmp()

8.1. Ejemplo con < setjmp.h>

main.c

#include <setjmp.h> void funcionx(jmp_buf,unsigned char); void main(void) { int valor; jmp_buf entorno; unsigned char cuenta = 1; valor = setjmp(entorno); if(valor!=0) { cuenta++; } funcionx(entorno,cuenta); } void funcionx(jmp_buf ent_buf, unsigned char c){ longjmp(ent_buf,c); }


Revisión: 1.0 [07/2012] 15

9. Librería <signal.h>

Esta librería se utiliza manipular señales que reporta el sistema durante la ejecución del programa. En C18 no está

implementada.

10. Librería <stdarg.h>

Esta librería se utiliza para crear y manipular argumentos de funciones. Ayuda a acceder a una lista de parámetros

mandados a una función.

Para declarar una función con parámetros variable:

void función(parámetros fijos, tipo, …);

En la función se debe definir de la siguiente manera:

void función(parámetros fijos, tipo num_args, …){ va_list ap;

va_start(ap, num_args); va_arg(ap,tipo); // Se debe llevar un control del parámetro en el que vamos y no pasarse de num_args. va_end(ap);

}



Macro void va_start(va_list ap, last_arg); Inicializa ap con las macros va_arg y va_end, es la primera que se debe llamar.

Macro tipo va_arg(va_list ap, tipo); Regresa el siguiente argumento. Macro void va_end(va_list ap); Permite que la función que utilizo va_start regrese

Variable typedef <tipo> va_list Es un tipo definido para acceder a los argumentos de una función usando las macros

10.1. Ejemplo con <stdarg.h>

main.c

#include<stdarg.h> #include<stdio.h> void suma(char *, unsigned char, ...); void main(void) { suma("La suma de 2+4+6+8+10 es: %d\n",5,2,4,6,8,10); // Mandamos todos esto parametros } void suma(char *cadena, unsigned char num_args, ...){ unsigned char com = 0; // Contador para sumar todos los valores va_list ap; unsigned char ciclo; // Contador de argumentos va_start(ap, num_args); // Inicializamos ap con los argumentos for(ciclo=0; ciclo < num_args; ciclo++) // Recorremos cada parametro com += va_arg(ap,unsigned char); // Leemos cada parametro con va_arg() printf(cadena, com); // mostramos el mensaje y la suma


Revisión: 1.0 [07/2012] 16

va_end(ap); // regresamos con va_end() }


Revisión: 1.0 [07/2012] 17

11. Librería <stddef.h>

Esta librería contiene algunas definiciones estándares, algunas pueden estar definidas en otras cabeceras.



Macro NULL Valor de una constante nula Macro offsetof(tipo, miembro); Regresa la posición o nivel donde se aloja el miembro en tipo

Variable typedef ptrdiff_t Variable para almacenar la diferencia entre dos punteros Variable typedef size_t Variable para almacenar el resultado de size_t() Variable typedef wchar_t Variable para almacenar un carácter

11.1. Ejemplo con <stddef.h>

stddef.h

/* $Id: stddef.h,v 1.2 2004/08/04 18:52:23 GrosbaJ Exp $ */ #ifndef __STDDEF_H #define __STDDEF_H typedef unsigned char wchar_t; /* ptrdiff_t is a bit tricky for a PIC because of the Harvard architecture. * We'll use the data memory size for the generic and define additional types * for specifics. */ typedef signed short int ptrdiff_t; typedef signed short int ptrdiffram_t; typedef signed short long int ptrdiffrom_t; /* size_t is tricky as well, for the same reason. 16 bits is sufficient * for data objects, but 24-bits are necessary for program memory objects. * This is true even for the 17Cxx architecture, as size_t is in bytes, and * the 17Cxx has an address range of 128Kbytes. We'll do the same thing * as we did for ptrdiff_t. */ typedef unsigned short int size_t; typedef unsigned short int sizeram_t; typedef unsigned short long int sizerom_t; /* NULL is a simple one. Many compilers define NULL as ((void*)0), which * is not best. A pointer to void is a pointer to data and a comparison * to a function pointer is a type mismatch and should result in an * error. The ANSI/ISO standard makes no guarantees about pointers to * data and pointers to code being at all related to one another. * * Since the standard requires that a pointer comparison to an integral * constant value of zero be allowed and is equivalent to a comparison * to the NULL pointer constant, we define NULL very simply, as '0'. */ #define NULL 0 /* offsetof() is a bit trickier. We define it in the standard way. The * compiler should be smart enough to evaluate the expression at compile * time and not run-time. It has to be as offsetof() is required by * 4.1.5 to evaluate to an integer constant expression. */ #define offsetof(type, member_designator) (size_t)(&(((type *)0)->member_designator)) #endif /* __STDDEF_H */


Revisión: 1.0 [07/2012] 18

main.c

#include<stddef.h> void main(void) { struct persona{ // Estructura char nombre[50]; // Posicion 0 char apellido[50]; // Posicion 50 int edad; // Posicion 100 int altura; // Posicion 102 }; unsigned int offset_nombre; unsigned int offset_apellido; unsigned int offset_edad; unsigned int offset_altura; offset_nombre = offsetof(struct persona,nombre); offset_apellido = offsetof(struct persona,apellido); offset_edad = offsetof(struct persona,edad); offset_altura = offsetof(struct persona,altura); }


Revisión: 1.0 [07/2012] 19

12. Librería <stdio.h>

Esta librería contiene prototipos, macros y tipos para manipular datos de entrada y salida. En C18 no hay entradas

utilizando las funciones estándares así que solo explicare las salidas implementadas en este compilador.

Las salidas (output streams) pueden ser:

_H_USER: Salida definida por el usuario utilizando _user_putc();

_H_USART: Salida del USART utilizando _usart_putc();

Las variables globales utilizadas para definir la salida por default son:

stdout = _H_USART;

stderr = _H_USART;



Macro MEM_MODEL Define el modelo de memoria que se está utilizando, por default es far

Macro EOF Define el final de archivo, lo regresan algunas funciones cuando hubo algún error

Macro FILE Es utilizado para definir el stream de salida Macro _H_USER Stream de salida definida por el usuario Macro _H_USART Stream de salida definida para el USART Macro FILE *stderr Stream salida estándar de error Macro FILE *stdout Stream de salida estándar

Función int printf (const rom char *fmt, …); Envía una cadena con formato a stdout (por default _H_USART), también el carácter nulo. Regresa: en error EOF, en otro caso la cantidad de caracteres enviados.

Función int fprintf (FILE *f, const rom char *fmt, …); Envía una cadena con formato al stream especificado (_H_USART o _H_USER), también el carácter nulo. Regresa: en error EOF, en otro caso la cantidad de caracteres enviados.

Función int sprintf(char *buf, const rom char *ftm, …); Envía una cadena con formato al buffer especificado, también el carácter nulo. Regresa: en error EOF, en otro caso la cantidad de caracteres enviados.

Función int puts (auto const rom char *s); Envía una cadena con ‘\n’ anexado al stdout (por default _H_USART), el carácter nulo no se envía. Regresa: en error EOF, en otro caso un valor positivo.

Función int fputs (const rom char *s, auto FILE *f); Envía una cadena con ‘\n’ anexado al stream especificado (_H_USART o _H_USER), el carácter nulo no se envía. Regresa: en error EOF, en otro caso un valor positivo.

Función int putc (char c, FILE *f); Envía un carácter al stream especificado (_H_USART o _H_USER). Regresa: en error EOF, en otro el carácter enviado.


Revisión: 1.0 [07/2012] 20

12.1. Ejemplo con <stdio.h>

stdio.h

#ifndef __STDIO_H #define __STDIO_H #include <stdarg.h> #include <stddef.h> /* Change this to near (or omit altogether) if building small memory model * versions of the libraries */ #define MEM_MODEL far #define EOF ((int)-1) typedef unsigned char FILE; /* output destination handles */ #define _H_USER ((FILE*)((int)-1)) #define _H_USART ((FILE*)((int)-2)) extern FILE *stderr; extern FILE *stdout; int putc (auto char c, auto FILE *f); int vsprintf (auto char *buf, auto const MEM_MODEL rom char *fmt, auto va_list ap); int vprintf (auto const MEM_MODEL rom char *fmt, auto va_list ap); int sprintf (auto char *buf, auto const MEM_MODEL rom char *fmt, ...); int printf (auto const MEM_MODEL rom char *fmt, ...); int fprintf (auto FILE *f, auto const MEM_MODEL rom char *fmt, ...); int vfprintf (auto FILE *f, auto const MEM_MODEL rom char *fmt, auto va_list ap); int puts (auto const MEM_MODEL rom char *s); int fputs (auto const MEM_MODEL rom char *s, auto FILE *f); #endif

main.c

#include<stdio.h> void main(void) { int cuenta; static const near rom char Cadena_NROM[] = "Cadena en NEAR ROM\n"; static const near rom char Cadena2_NROM[] = "Cadena en NEAR ROM"; static const far rom char Cadena2_FROM[] = "Cadena en FAR ROM"; static const far rom char Cadena_FROM[] = "Cadena en FAR ROM\n"; static const char Cadena_RAM[] = "Cadena en RAM\n"; static const char Cadena2_RAM[] = "Cadena en RAM"; char* Cadena[20]; // int printf (auto const MEM_MODEL rom char *fmt, ...); // Envía una cadena con formato a stdout (por default _H_USART) incluyendo el carácter nulo // RETORNA: en algún error regresa EOF, en otro caso el numero de caracteres enviados printf("01. Hola mundo!!\n"); // Texto en ROM printf("02. "); printf(Cadena_NROM); // Texto en Near ROM printf("03. "); cuenta = printf(Cadena_FROM); // Texto en Far ROM printf("04. Caracteres mandados: %i\n", cuenta); // Cuantos caracteres se mandaron //printf(Cadena_RAM); // Texto en RAM, utilizar %s para mandar el texto // Conversiones para printf(), fprintf(), sprintf(), vfprintf(), vprintf() y vsprintf() printf("05. %s",Cadena_RAM); // Cadena en RAM printf("06. %S",Cadena_NROM); // Cadena en Near ROM printf("07. %HS",Cadena_FROM); // Cadena en Far ROM printf("08. %% \\ \' \" \? \t \n\0"); // \t = TAB, \r = Retorno, \n = Nueva línea, \0 = Nulo printf("09. %c, %c, %c\n",0,255,'A'); // Carácter, unsigned char printf("10. %d, %i\n",(int)-32767,(int)32767); // Decimal con signo, int printf("11. %u, %u\n",(unsigned int)0,(unsigned int)65535);// Decimal sin signo, unsigned int printf("12. %o, %o\n",(unsigned int)0,(unsigned int)65535);// Octal, unsigned int printf("13. %b, %B\n",(unsigned int)0,(unsigned int)65535);// Binario, unsigned int printf("14. %x, %X\n",(unsigned int)0,(unsigned int)65535);// Hex, x = min, X = may, unsigned int


Revisión: 1.0 [07/2012] 21

printf("15. %p, %P\n",(unsigned int)0,(unsigned int)65535);// Puntero a NRAM o ROM, p = x, P = X, 16-b printf("16. %Hp, %HP\n",(unsigned short long)0,(unsigned short long)16777215);// Pun. FRAM o ROM, 24-b // Tamaño (Aplica: d,i,u,o,b,B,x,X,p,P) para printf(), fprintf(), sprintf(), vfprintf(), vprintf() y vsprintf() // hh (8b) espera que el valor a convertir sea signed char o unsigned char printf("17. %hhd, %hhi\n",(char)-127,(char)127); // hhd, hhi = signed char printf("18. %hhu, %hhu\n",(unsigned char)0,(unsigned char)255); // hhu = unsigned char printf("19. %hho, %hho\n",(unsigned char)0,(unsigned char)255); // hho = unsigned char printf("20. %hhb, %hhB\n",(unsigned char)0,(unsigned char)255); // hhb, hhB = unsigned char printf("21. %hhx, %hhX\n",(unsigned char)0,(unsigned char)255); // hhx, hhX = unsigned char printf("22. %hhp, %hhP\n",(unsigned int)0,(unsigned int)65535); // hhp, hhP = unsigned int (pon. uc) // h,[t,z] (16b) espera que el valor a convertir sea int o unsigned int (por default es así es) printf("23. %hd, %hi\n",(int)-32767,(int)32767); // hd, hi = signed int printf("24. %hu, %hu\n",(unsigned int)0,(unsigned int)65535); // hu = unsigned int printf("25. %ho, %ho\n",(unsigned int)0,(unsigned int)65535); // ho = unsigned int printf("26. %hb, %hB\n",(unsigned int)0,(unsigned int)65535); // hb, hB = unsigned int printf("27. %hx, %hX\n",(unsigned int)0,(unsigned int)65535); // hx, hX = unsigned int printf("28. %hp, %hP\n",(unsigned int)0,(unsigned int)65535); // hp, hP = unsigned int (0-FFFF) // H,[T,Z] (24b) espera que el valor a convertir sea short long o unsigned short long printf("29. %Hd, %Hi\n",(short long)-8388607,(short long)8388607); // Hd, Hi = sl printf("30. %Hu, %Hu\n",(unsigned short long)0,(unsigned short long)16777215); // Hu = usl printf("31. %Ho, %Ho\n",(unsigned short long)0,(unsigned short long)16777215); // Ho = usl printf("32. %Hb, %HB\n",(unsigned short long)0,(unsigned short long)16777215); // Hb, HB = usl printf("33. %Hx, %HX\n",(unsigned short long)0,(unsigned short long)16777215); // Hx, HX = usl printf("34. %Hp, %HP\n",(unsigned short long)0,(unsigned short long)16777215); // Hp, HP = usl // l,[j] (32b) espera que el valor a convertir sea long o unsigned long printf("35. %ld, %li\n",(long)-2147483647,(long)2147483647); // ld, li = long printf("36. %lu, %lu\n",(unsigned long)0,(unsigned long)4294967295); // lu = unsigned long printf("37. %lo, %lo\n",(unsigned long)0,(unsigned long)4294967295); // Ho = unsigned long printf("38. %lb, %lB\n",(unsigned long)0,(unsigned long)4294967295); // Hb, HB = unsigned long printf("39. %lx, %lX\n",(unsigned long)0,(unsigned long)4294967295); // Hx, HX = unsigned long // Ancho del campo para printf(), fprintf(), sprintf(), vfprintf(), vprintf() y vsprintf() // Constante para definir el ancho (Se rellena con espacio) printf("40. %35s",Cadena_RAM); // Cadena en RAM printf("41. %35S",Cadena_NROM); // Cadena en NROM printf("42. %35HS",Cadena_FROM); // Cadena en FROM printf("43. %16c, %16c\n", 'a','b'); // Carácter printf("44. %16d, %16i\n",(int)-32767,(int)32767); // Entero con signo printf("45. %16u, %16u\n",(unsigned int)0,(unsigned int)65535); // Entero sin signo printf("46. %16o, %16o\n",(unsigned int)0,(unsigned int)65535); // Octal printf("47. %16b, %16B\n",(unsigned int)0,(unsigned int)65535); // Binario printf("48. %16x, %16X\n",(unsigned int)0,(unsigned int)65535); // Hexadecimal printf("49. %16p, %16P\n",(unsigned int)0,(unsigned int)65535); // Puntero RAM o NROM printf("50. %16Hp, %16HP\n",(unsigned short long)0,(unsigned short long)4294967295);// Puntero FROM // * Para definir el ancho durante la ejecución printf("51. %*s",35,Cadena_RAM); // Cadena en RAM printf("52. %*S",35,Cadena_NROM); // Cadena en NROM printf("53. %*HS",35,Cadena_FROM); // Cadena en FROM printf("54. %*c, %*c\n",16,'a',16,'b'); // Carácter printf("55. %*d, %*i\n",16,(int)-32767,16,(int)32767); // Entero con signo printf("56. %*u, %*u\n",16,(unsigned int)0,16,(unsigned int)65535); // Entero sin signo printf("57. %*o, %*o\n",16,(unsigned int)0,16,(unsigned int)65535); // Octal printf("58. %*b, %*B\n",16,(unsigned int)0,16,(unsigned int)65535); // Binario printf("59. %*x, %*X\n",16,(unsigned int)0,16,(unsigned int)65535); // Hexadecimal printf("60. %*p, %*P\n",16,(unsigned int)0,16,(unsigned int)65535); // Puntero RAM o NROM printf("61. %*Hp, %*HP\n",16,(unsigned short long)0,16,(unsigned short long)4294967295); // Pun. FROM // Precisión del campo (Aplica: d,i,u,o,b,B,x,X,p,P,Hp,HP) para printf(), fprintf(), sprintf(), vfprintf(), vprintf() y vsprintf() // Constante para definir la precisión printf("62. %.11s\n",Cadena_RAM); // Si la precisión es mayor termina cuando encuentra '\0' printf("63. %.11S\n",Cadena_NROM); // Si la precisión es mayor termina cuando encuentra '\0' printf("64. %.11HS\n",Cadena_FROM); // Si la precisión es mayor termina cuando encuentra '\0' printf("65. %.16d, %.16i\n",(int)-32767,(int)32767);// Se rellena con ceros si la precisión es mayor printf("66. %.16u, %.16u\n",(unsigned int)0,(unsigned int)65535); // Se rellena con ceros si la precisión es mayor printf("67. %.16o, %.16o\n",(unsigned int)0,(unsigned int)65535); // Se rellena con ceros si la precisión es mayor printf("68. %.16b, %.16B\n",(unsigned int)0,(unsigned int)65535); // Se rellena con ceros si la precisión es mayor printf("69. %.16x, %.16X\n",(unsigned int)0,(unsigned int)65535); // Se rellena con ceros si la precisión es mayor printf("70. %.16p, %.16P\n",(unsigned int)0,(unsigned int)65535); // Se rellena con ceros si la precisión es mayor printf("71. %.16Hp, %.16HP\n",(unsigned short long)0,(unsigned short long)4294967295); // Se rellena


Revisión: 1.0 [07/2012] 22

con ceros si la precisión es mayor // * Para definir la precisión durante la ejecución printf("72. %.*s\n",11,Cadena_RAM); // Si la precisión es mayor termina cuando encuentra '\0' printf("73. %.*S\n",11,Cadena_NROM); // Si la precisión es mayor termina cuando encuentra '\0' printf("74. %.*HS\n",11,Cadena_FROM); // Si la precisión es mayor termina cuando encuentra '\0' printf("75. %.*d, %.*i\n",16,(int)-32767,16,(int)32767); // Se rellena con ceros si la precisión es mayor printf("76. %.*u, %.*u\n",16,(unsigned int)0,16,(unsigned int)65535);// Se rellena con ceros si la precisión es mayor printf("77. %.*o, %.*o\n",16,(unsigned int)0,16,(unsigned int)65535);// Se rellena con ceros si la precisión es mayor printf("78. %.*b, %.*B\n",16,(unsigned int)0,16,(unsigned int)65535);// Se rellena con ceros si la precisión es mayor printf("79. %.*x, %.*X\n",16,(unsigned int)0,16,(unsigned int)65535);// Se rellena con ceros si la precisión es mayor printf("80. %.*p, %.*P\n",16,(unsigned int)0,16,(unsigned int)65535);// Se rellena con ceros si la precisión es mayor printf("81. %.*Hp, %.*HP\n",16,(unsigned short long)0,16,(unsigned short long)4294967295); // Se rellena con ceros si la precisión es mayor // Banderas para printf(), fprintf(), sprintf(), vfprintf(), vprintf() y vsprintf() // # Forma alterna (Aplica: o,b,B,x,X,p,P,Hp,HP) printf("82. %#o, %#o\n",(unsigned int)0,(unsigned int)65535); // Añade 0 al inicio printf("83. %#b, %#B\n",(unsigned int)0,(unsigned int)65535); // Añade 0b o 0B al inicio printf("84. %#x, %#X\n",(unsigned int)0,(unsigned int)65535); // Añade 0x o 0X al inicio printf("85. %#p, %#P\n",(unsigned int)0,(unsigned int)65535); // Añade 0x o 0X al inicio, 16-b printf("86. %#Hp, %#HP\n",(unsigned short long)0,(unsigned short long)4294967295); // Añade 0x p 0X al inicio, 24-b // + El resultado tendrá el signo (Aplica: d,i) (por default solo los negativos tienen signo) printf("87. %+d, %+i\n",(int)-32767,(int)32767); // Decimal con signo, int // espacio El resultado positivo tendrá un espacio en lugar del signo + (Solo para d,i) (por default no se deja espacio) printf("88. % d, % i\n",(int)-32767,(int)32767); // Decimal con signo, int // 0 Rellena con ceros al inicio para completar el ancho (Aplica: d,i,o,u,b,B,x,X,p,P,Hp,HP) printf("89. %016d, %016i\n",(int)-32767,(int)32767); // Decimal con signo, int printf("90. %016u, %016u\n",(unsigned int)0,(unsigned int)65535); // Decimal sin signo, unsigned int printf("91. %016o, %016o\n",(unsigned int)0,(unsigned int)65535); // Octal, unsigned int printf("92. %016b, %016B\n",(unsigned int)0,(unsigned int)65535); // Binario, unsigned int printf("93. %016x, %016X\n",(unsigned int)0,(unsigned int)65535); // Hex, x = min, X = may, ui printf("94. %016p, %016P\n",(unsigned int)0,(unsigned int)65535); // Pun. a NRAM o ROM, p = x, P = X, 16-b printf("95. %016Hp, %016HP\n",(unsigned short long)0,(unsigned short long)4294967295);// Puntero a FRAM o ROM, 24-b // - Justificar texto a la izquierda (por default es derecha) printf("96. %-18s\n",Cadena2_RAM); // La cadena no debe tener fin de línea en la variable printf("97. %-18S\n",Cadena2_NROM); // La cadena no debe tener fin de línea en la variable printf("98. %-18HS\n",Cadena2_FROM); // La cadena no debe tener fin de línea en la variable printf("99. %-16c, %-16c\n", 'a','b'); // Carácter printf("100. %-16d, %-16i\n",(int)-32767,(int)32767); // Entero con signo printf("101. %-16u, %-16u\n",(unsigned int)0,(unsigned int)65535); // Entero sin signo printf("102. %-16o, %-16o\n",(unsigned int)0,(unsigned int)65535); // Octal printf("103. %-16b, %-16B\n",(unsigned int)0,(unsigned int)65535); // Binario printf("104. %-16x, %-16X\n",(unsigned int)0,(unsigned int)65535); // Hexadecimal printf("105. %-16p, %-16P\n",(unsigned int)0,(unsigned int)65535); // Puntero RAM o NROM printf("106. %-16Hp, %-16HP\n",(unsigned short long)0,(unsigned short long)4294967295);// Puntero FROM // int fprintf (auto FILE *f, auto const MEM_MODEL rom char *fmt, ...); // Envía una cadena con formato al stream especificado (_H_USART o _H_USER) incluyendo el carácter nulo // RETORNA: en algún error regresa EOF, en otro caso el numero de caracteres enviados fprintf(_H_USART,"107. Hola mundo!!\n"); // Texto en ROM printf("108. "); fprintf(_H_USART,Cadena_NROM); // Texto en Near ROM printf("109. "); fprintf(_H_USART,Cadena_FROM); // Texto en Far ROM fprintf(_H_USART,"110. %s",Cadena_RAM); // Cadena en RAM fprintf(_H_USART,"111. %S",Cadena_NROM); // Cadena en Near ROM fprintf(_H_USART,"112. %HS",Cadena_FROM); // Cadena en Far ROM fprintf(_H_USART,"113. %% \\ \' \" \? \t \n\0");// \t = TAB, \r = Retorno, \n = Nueva línea, \0 = Nulo fprintf(_H_USART,"114. %c, %c, %c\n",0,255,'A'); // Carácter, unsigned char fprintf(_H_USART,"115. %d, %i\n",(int)-32767,(int)32767); // Decimal con signo, int fprintf(_H_USART,"116. %u, %u\n",(unsigned int)0,(unsigned int)65535); // Decimal sin signo, ui fprintf(_H_USART,"117. %o, %o\n",(unsigned int)0,(unsigned int)65535); // Octal, unsigned int fprintf(_H_USART,"118. %b, %B\n",(unsigned int)0,(unsigned int)65535); // Binario, unsigned int fprintf(_H_USART,"119. %x, %X\n",(unsigned int)0,(unsigned int)65535); // Hex, x = min, X = may, ui fprintf(_H_USART,"120. %p, %P\n",(unsigned int)0,(unsigned int)65535); // Puntero a NRAM o ROM, p = x, P = X, 16-b fprintf(_H_USART,"121. %Hp, %HP\n",(unsigned short long)0,(unsigned short long)16777215);// Puntero a FRAM o ROM, 24-b


Revisión: 1.0 [07/2012] 23

// int sprintf (auto char *buf, auto const MEM_MODEL rom char *fmt, ...); // Envía una cadena con formato al buffer especificado, incluyendo el carácter nulo // RETORNA: en algún error regresa EOF, en otro caso el numero de caracteres enviados sprintf(Cadena,"Hola mundo!!\n"); // Texto en ROM printf("122. %s",Cadena); sprintf(Cadena,Cadena_NROM); // Texto en Near ROM printf("123. %s",Cadena); sprintf(Cadena,Cadena_FROM); // Texto en Far ROM printf("124. %s",Cadena); sprintf(Cadena,"%s",Cadena_RAM); // Cadena en RAM printf("125. %s",Cadena); sprintf(Cadena,"%S",Cadena_NROM); // Cadena en Near ROM printf("126. %s",Cadena); sprintf(Cadena,"%HS",Cadena_FROM); // Cadena en Far ROM printf("127. %s",Cadena); sprintf(Cadena,"%% \\ \' \" \? \t \n\0"); // \t = TAB, \r = Retorno, \n = Nueva línea, \0 = Nulo printf("128. %s",Cadena); sprintf(Cadena,"%c, %c, %c\n",0,255,'A'); // Carácter, unsigned char printf("129. %s",Cadena); sprintf(Cadena,"%d, %i\n",(int)-32767,(int)32767); // Decimal con signo, int printf("130. %s",Cadena); sprintf(Cadena,"%u, %u\n",(unsigned int)0,(unsigned int)65535);// Decimal sin signo, unsigned int printf("131. %s",Cadena); sprintf(Cadena,"%o, %o\n",(unsigned int)0,(unsigned int)65535);// Octal, unsigned int printf("132. %s",Cadena); sprintf(Cadena,"%b, %B\n",(unsigned int)0,(unsigned int)65535);// Binario, unsigned int printf("133. %s",Cadena); sprintf(Cadena,"%x, %X\n",(unsigned int)0,(unsigned int)65535);// Hexadecimal, x = minúsculas, X = mayúsculas, unsigned int printf("134. %s",Cadena); sprintf(Cadena,"%p, %P\n",(unsigned int)0,(unsigned int)65535);// Puntero a near ram o rom, p = x, P = X, 16-b printf("135. %s",Cadena); sprintf(Cadena,"%Hp, %HP\n",(unsigned short long)0,(unsigned short long)16777215);// Puntero a FRAM o ROM, 24-b // int puts (auto const MEM_MODEL rom char *s); // Envía una cadena con carácter nulo a stdout, se añade '\n' al final y no envía el carácter nulo // RETORNA: en algún error regresa EOF, en otro caso un valor no negativo puts("136. Hola mundo!!"); // Texto en ROM printf("137. "); puts(Cadena2_NROM); // Texto en Near ROM printf("138. "); puts(Cadena2_FROM); // Texto en Far ROM //puts(Cadena2_RAM); // Texto en RAM (solo acepta a ROM) // int fputs (auto const MEM_MODEL rom char *s, auto FILE *f); // Envía una cadena con carácter nulo al stream especificado(_H_USART o _H_USER), se añade '\n' al final (No se añade '\n' no se por qué!!) y no se envía el carácter nulo // RETORNA: en algún error regresa EOF, en otro caso un valor no negativo fputs("139. Hola mundo!!\n",_H_USART); // Texto en ROM printf("140. "); fputs(Cadena_NROM,_H_USART); // Texto en Near ROM printf("141. "); fputs(Cadena_FROM,_H_USART); // Texto en Far ROM //puts(Cadena_RAM); // Texto en RAM (solo acepta a ROM) // int putc (auto char c, auto FILE *f); // Envía un carácter al stream especificado (_H_USART o _H_USER) // RETORNA: en algún error regresa EOF, en otro caso el carácter enviado printf("142. "); putc('a',_H_USART); putc('\n',_H_USART); printf("143. "); putc('b',_H_USART); putc('\n',_H_USART); printf("144. "); putc('C',_H_USART); putc('\n',_H_USART); } 01. Hola mundo!! 02. Cadena en NEAR ROM 03. Cadena en FAR ROM 04. Caracteres mandados: 18 05. Cadena en RAM 06. Cadena en NEAR ROM 07. Cadena en FAR ROM 08. % \ ' " ? 09. , •, A 10. -32767, 32767 11. 0, 65535 12. 0, 177777 13. 0, 1111111111111111 14. 0, FFFF 15. 0, FFFF 16. 0, FFFFFF 17. -127, 127 18. 0, 255


Revisión: 1.0 [07/2012] 24

19. 0, 377 20. 0, 11111111 21. 0, FF 22. 0, FFFF 23. -32767, 32767 24. 0, 65535 25. 0, 177777 26. 0, 1111111111111111 27. 0, FFFF 28. 0, FFFF 29. -8388607, 8388607 30. 0, 16777215 31. 0, 77777777 32. 0, 111111111111111111111111 33. 0, FFFFFF 34. 0, FFFFFF 35. -2147483647, 2147483647 36. 0, 4294967295 37. 0, 37777777777 38. 0, 11111111111111111111111111111111 39. 0, FFFFFFFF 40. Cadena en RAM 41. Cadena en NEAR ROM 42. Cadena en FAR ROM 43. a, b 44. -32767, 32767 45. 0, 65535 46. 0, 177777 47. 0, 1111111111111111 48. 0, FFFF 49. 0, FFFF 50. 0, FFFFFF 51. Cadena en RAM 52. Cadena en NEAR ROM 53. Cadena en FAR ROM 54. a, b 55. -32767, 32767 56. 0, 65535 57. 0, 177777 58. 0, 1111111111111111 59. 0, FFFF 60. 0, FFFF 61. 0, FFFFFF 62. Cadena en R 63. Cadena en N 64. Cadena en F 65. -000000000032767, 0000000000032767 66. 0000000000000000, 0000000000065535 67. 0000000000000000, 0000000000177777 68. 0000000000000000, 1111111111111111 69. 0000000000000000, 000000000000FFFF 70. 0000000000000000, 000000000000FFFF 71. 0000000000000000, 0000000000FFFFFF 72. Cadena en R 73. Cadena en N 74. Cadena en F 75. -000000000032767, 0000000000032767 76. 0000000000000000, 0000000000065535 77. 0000000000000000, 0000000000177777 78. 0000000000000000, 1111111111111111 79. 0000000000000000, 000000000000FFFF 80. 0000000000000000, 000000000000FFFF 81. 0000000000000000, 0000000000FFFFFF 82. 00, 0177777 83. 0b0, 0B1111111111111111 84. 0x0, 0XFFFF 85. 0x0, 0XFFFF 86. 0x0, 0XFFFFFF 87. -32767, +32767 88. -32767, 32767 89. -000000000032767, 0000000000032767 90. 0000000000000000, 0000000000065535 91. 0000000000000000, 0000000000177777 92. 0000000000000000, 1111111111111111 93. 0000000000000000, 000000000000FFFF 94. 0000000000000000, 000000000000FFFF 95. 0000000000000000, 0000000000FFFFFF


Revisión: 1.0 [07/2012] 25

96. Cadena en RAM 97. Cadena en NEAR ROM 98. Cadena en FAR ROM 99. a , b 100. -32767 , 32767 101. 0 , 65535 102. 0 , 177777 103. 0 , 1111111111111111 104. 0 , FFFF 105. 0 , FFFF 106. 0 , FFFFFF 107. Hola mundo!! 108. Cadena en NEAR ROM 109. Cadena en FAR ROM 110. Cadena en RAM 111. Cadena en NEAR ROM 112. Cadena en FAR ROM 113. % \ ' " ? 114. , •, A 115. -32767, 32767 116. 0, 65535 117. 0, 177777 118. 0, 1111111111111111 119. 0, FFFF 120. 0, FFFF 121. 0, FFFFFF 122. Hola mundo!! 123. Cadena en NEAR ROM 124. Cadena en FAR ROM 125. Cadena en RAM 126. Cadena en NEAR ROM 127. Cadena en FAR ROM 128. % \ ' " ? 129. 130. -32767, 32767 131. 0, 65535 132. 0, 177777 133. 0, 1111111111111111 134. 0, FFFF 135. 0, FFFF 136. Hola mundo!! 137. Cadena en NEAR ROM 138. Cadena en FAR ROM 139. Hola mundo!! 140. Cadena en NEAR ROM 141. Cadena en FAR ROM 142. a 143. b 144. C


Revisión: 1.0 [07/2012] 26

13. Librería <stdlib.h>

Esta librería se utiliza para convertir datos, al igual que la anterior no todas las funciones del ANSI C están definidas

por los recursos limitados de los microcontroladores, así que solamente explicare aquellas definidas en C18 (Las

marcadas en negrita son funciones que forman parte del ANSI).



Macro RAND_MAX Macro que define el valor máximo que puede regresar la función rand()

Función char atob (const char *s); Convierte una cadena a 8 bits con signo, puede llevar al inicio + o -, radix 10 [-128, 127]

Función double atof (const char *s); Convierte una cadena a 32 bits flotante, radix 10 [1.17549435E-38, 6.80564693E+38]

Función int atoi (const char *s); Convierte una cadena a 16 bits con signo, puede llevar al inicio + o -, radix 10 [-32768, 32767]

Función long atol (const char *s); Convierte una cadena a 32 bits con signo, puede llevar al inicio + o -, radix 10 [-2147483648, 2147483647]

Función char *btoa (signed char value, char *s); Convierte un valor de 8 bits con signo a cadena, [-128, 127]

Función char *itoa (int value, char *s); Convierte un valor de 16 bits con signo a cadena, [-32768, 32767]

Función char *ltoa (long value, char *s); Convierte un valor de 32 bits con signo a cadena, [-2147483648, 2147483647]

Función char *ultoa (unsigned long value, char *s); Convierte un valor de 32 bits sin signo a cadena, [0, 4294967295]

Función unsigned long atoul (const char *s); Convierte una cadena a 32 bits sin signo, puede llevar al inicio +, radix 10 [0, 4294967295]

Función int rand (void); Regresa un valor aleatorio tipo entero, [0, RAND_MAX]

Función void srand (unsigned int seed); Se utiliza para alimentar la función rand(), si el valor dado siempre es el mismo rand() regresara la misma secuencia siempre, [0,65535]

13.1. Ejemplo con <stdlib.h>

stdlib.h

/* $Id: stdlib.h,v 1.1 2003/12/09 22:54:19 GrosbaJ Exp $ */ #ifndef __STDLIB_H #define __STDLIB_H #if __18CXX /** @name String Conversion Functions * If the value of the result for a function cannot be represented by the * type of the return value of that function, the behaviour is undefined. */ /*@{*/ /** @name atof * The {\bf atof} function converts the initial portion of the string pointed * to by {\bf s} into a floating-point {\bf double} representation. * @param s pointer to the string to convert * @return The {\bf atof} function returns the converted value */ double atof (const auto char *s); /** @name atob * The {\bf atob} function converts the string pointed to by {\bf s} into a


Revisión: 1.0 [07/2012] 27

* {\bf signed char} integer representation. Characters are recognized in the * following order: An optional string of tabs and spaces, An optional sign, * A string of digits. The first unrecognized character ends the conversion. * Overflow results are undefined. * The {\bf atob} function is an MPLAB-Cxx extension to the ANSI required * libraries and may not be present in other implementations. * @param s pointer to the string to convert * @return The {\bf atob} function returns the converted value as a signed char */ signed char atob (const auto char *s); /** @name atoi * The {\bf atoi} function converts the string pointed to by {\bf s} into a * {\bf int} integer representation. Characters are recognized in the * following order: An optional string of tabs and spaces, An optional sign, * A string of digits. The first unrecognized character ends the conversion. * Overflow results are undefined. * @param s pointer to the string to convert * @return The {\bf atoi} function returns the converted value as an int */ int atoi (const auto char *s); /** @name atol * The {\bf atol} function converts the initial portion of the string pointed * to by {\bf s} into a {\bf long} integer representation. The initial portion * of the string is assumed to be in radix 10. * @param s pointer to the string to convert * @return The {\bf atol} function returns the converted value */ long atol (const auto char *s); /** @name atoul * The {\bf atoul} function converts the initial portion of the string pointed * to by {\bf s} into a {\bf unsigned long} integer representation. * The initial portion of the string is assumed to be in radix 10. * * The {\bf atoul} function is an MPLAB-Cxx extension to the ANSI required * libraries and may not be present in other implementations. * @param s pointer to the string to convert * @return The {\bf atoul} function returns the converted value */ unsigned long atoul (const auto char *s); /** @name btoa * The {\bf btoa} function converts the {\bf signed char} value {\bf value} to * a radix 10 string representation, storing the resultant string into * the location pointed to by {\bf s}. * * The {\bf btoa} function is an MPLAB-Cxx extension to the ANSI required * libraries and may not be present in other implementations. * @param value value to convert * @param s pointer to destination string object * @return The {\bf btoa} function returns the value of {\bf s}. */ char *btoa (auto signed char value, auto char *s); /** @name itoa * The {\bf itoa} function converts the {\bf int} value {\bf value} to * a radix 10 string representation, storing the resultant string into * the location pointed to by {\bf s}. * * The {\bf itoa} function is an MPLAB-Cxx extension to the ANSI required * libraries and may not be present in other implementations. * @param value value to convert * @param s pointer to destination string object * @return The {\bf itoa} function returns the value of {\bf s}. */ char *itoa (auto int value, auto char *s); /** @name ltoa * The {\bf ltoa} function converts the {\bf long} value {\bf value} to * a radix 10 string representation, storing the resultant string into * the location pointed to by {\bf s}. * * The {\bf ltoa} function is an MPLAB-Cxx extension to the ANSI required * libraries and may not be present in other implementations. * @param value value to convert * @param s pointer to destination string object * @return The {\bf ltoa} function returns the value of {\bf s}. */ char *ltoa (auto long value, auto char *s);


Revisión: 1.0 [07/2012] 28

/** @name ultoa * The {\bf ultoa} function converts the {\bf unsigned long} value {\bf value} to * a radix 10 string representation, storing the resultant string into * the location pointed to by {\bf s}. * * The {\bf ultoa} function is an MPLAB-Cxx extension to the ANSI required * libraries and may not be present in other implementations. * @param value value to convert * @param s pointer to destination string object * @return The {\bf ultoa} function returns the value of {\bf s}. */ char *ultoa (auto unsigned long value, auto char *s); /*@}*/ /** @name Pseudo-Random Sequence Generation Functions */ /*@{*/ /** @name RAND_MAX * The maximum value which can be returned by the {\bf rand} function. */ #define RAND_MAX 32767 /** @name rand * The {\bf rand} function generates a sequence of pseudo-random integer * values in the range [0,RAND_MAX]. * * The implementation shall behave as if no library function calls {\bf rand}. */ int rand (void); /** @name srand * The {\bf srand} function sets the starting seed for the pseudo-random * number sequence generated by the {\bf rand} function. If {\bf srand} is * called again with the same seed value, the same sequence of value shall * be returned by {\bf rand}. If {\bf rand} is called without {\bf srand} * having first been called, the pseudo-random sequence of numbers generated * shall be the same as if {\bf srand} had been called with a seed value * of 1. * * The implementation shall behave as if no library function calls {\bf srand}. */ void srand (auto unsigned int seed); /*@}*/ #else void btoa(static char , static char *); void ubtoa(static unsigned char ,static char *); char atob(static char *); unsigned char atoub(static char *); void itoa(static int,static char *); void uitoa(static unsigned int,static char *); int atoi(static char *); unsigned int atoui(static char *); #endif #endif

main.c

#include <stdio.h> #include <stdlib.h> void main(void) { static char s8_min[] = "-128"; static char s8_max[] = "127"; static char s8_alt[] = "+127"; static char s16_min[] = "-32768"; static char s16_max[] = "32767"; static char s16_alt[] = "+32767"; static char s32_min[] = "-2147483648"; static char s32_max[] = "2147483647"; static char s32_alt[] = "+2147483647"; static char u32_min[] = "0"; static char u32_max[] = "4294967295"; static char u32_alt[] = "+4294967295"; static char f32_min[] = "1.17549435E-30"; static char f32_max[] = "6.80564693E+37"; static char f32_alt[] = "3.14159265"; float f1,f2,f3;


Revisión: 1.0 [07/2012] 29

char c_min = -128; char c_max = 127; int i_min = -32768; int i_max = 32767; long l_min = -2147483648; long l_max = 2147483647; unsigned long ul_min = 0; unsigned long ul_max = 4294967295; char Cad[20],Cad2[20]; // char atob(s8): Convierte una cadena a 8 bits con signo, puede llevar al inicio + o -, radix 10 [-128,127] printf("01. %hhi,%hhi,%hhi\n",atob(s8_min),atob(s8_max),atob(s8_alt)); // int atoi(s16): Convierte una cadena a 16 bits con signo, puede llevar al inicio + o -, radix 10 [-32768, 32767] printf("02. %hi,%hi,%hi\n",atoi(s16_min),atoi(s16_max),atoi(s16_alt)); // long atol(s32): Convierte una cadena a 32 bits con signo, puede llevar al inicio + o -, radix 10 [-2147483648, 2147483647] printf("03. %li,%li,%li\n",atol(s32_min),atol(s32_max),atol(s32_alt)); // unsigned long atoul(u32): Convierte una cadena a 32 bits sin signo, puede llevar al inicio +, radix 10 [0, 4294967295] printf("04. %lu,%lu,%lu\n",atoul(u32_min),atoul(u32_max),atoul(u32_alt)); // double atof(const char*): Convierte una cadena a 32 bits flotante, radix 10 [1.17549435E-38, 6.80564693E+38] // Esta función genera un resultado menos preciso que asignar una constante. // http://ww1.microchip.com/downloads/en/DeviceDoc/MPLAB-C18-v3_31-README.html#SSR18624 f1 = atof(f32_min); // f1 = 1.175494e-030 f2 = atof(f32_max); // f2 = 6.805647e+037 f3 = atof(f32_alt); // f3 = 3.141593 // char* btoa(s8, char*): Convierte un valor de 8 bits con signo a cadena, [-128, 127] btoa(c_min,Cad); btoa(c_max,Cad2); printf("05. %s,%s\n",Cad,Cad2); // char* itoa(s16, char*): Convierte un valor de 16 bits con signo a cadena, [-32768, 32767] itoa(i_min,Cad); itoa(i_max,Cad2); printf("06. %s,%s\n",Cad,Cad2); // char* ltoa(s32, char*): Convierte un valor de 32 bits con signo a cadena, [-2147483648, 2147483647] ltoa(l_min,Cad); ltoa(l_max,Cad2); printf("07. %s,%s\n",Cad,Cad2); // char* ultoa(ul32, char*): Convierte un valor de 32 bits sin signo a cadena, [0, 4294967295] ultoa(ul_min,Cad); ultoa(ul_max,Cad2); printf("08. %s,%s\n",Cad,Cad2); // int rand(void): Regresa un valor aleatorio tipo entero, [0, 32767 (RAND_MAX)] printf("09. %i,%i,%i,%i\n",rand(),rand(),rand(),rand()); // srand(unsigned int): Se utiliza para alimentar la función rand(), si el valor dado siempre es el mismo rand() regresara la misma secuencia siempre, [0,65535] srand(100); printf("10. %i,%i,%i,%i\n",rand(),rand(),rand(),rand()); } 01. -128,127,127 02. -32768,32767,32767 03. -2147483648,2147483647,2147483647 04. 0,4294967295,4294967295 05. -128,127 06. -32768,32767 07. -2147483648,2147483647 08. 0,4294967295 09. 4764,655,20502,7009 10. 31200,2371,5754,2229


Revisión: 1.0 [07/2012] 30

14. Librería <string.h>

Esta librería se utiliza para manipular cadenas de caracteres y áreas de memoria, al igual que algunas librerías

anterior no todas las funciones del ANSI C están definidas, así que solamente explicare aquellas definidas en C18

(Las marcadas en negrita son funciones que forman parte del ANSI).



Macro MEM_MODEL Define el modelo de memoria, puede ser far o near (por default es far)

Función void *memchr (const void *s, unsigned char c, size_t n); Busca el byte c en la región de memoria RAM s hasta n bytes Regresa: La posición del byte, en otro caso nulo.

Función MEM_MODEL rom char *memchrpgm (const MEM_MODEL rom char *s, const unsigned char c, sizerom_t n);

Busca el char c en la región de memoria ROM s hasta n bytes Regresa: La posición del byte, en otro caso nulo.

Función signed char memcmp (const void *s1, const void *s2, size_t n); Compara el contenido de dos arreglos de bytes RAM hasta n bytes. Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char memcmppgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n);

Compara el contenido de dos arreglos de bytes ROM hasta n bytes. Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char memcmppgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n);

Compara el contenido de dos arreglos de bytes RAMvsROM hasta n bytes. Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char memcmpram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n);

Compara el contenido de dos arreglos de bytes ROMvsRAM hasta n bytes. Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función void *memcpy (void *s1, const void *s2, size_t n); Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (NSP), RAMaRAM Regresa: La dirección de s1

Función MEM_MODEL rom void *memcpypgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n);

Copia el contenido de s2 a s1 hasta n elementos, (NSP), ROMaROM (Externa) Regresa: La dirección de s1

Función void *memcpypgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n);

Copia el contenido de s2 a s1 hasta n elementos, (NSP), ROMaRAM Regresa: La dirección de s1

Función MEM_MODEL rom void *memcpyram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n);

Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (NSP), RAMaROM (Externa) Regresa: La dirección de s1

Función void *memmove (void *s1, const void *s2, size_t n); Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (SSP), RAMaRAM Regresa: La dirección de s1

Función MEM_MODEL rom void *memmovepgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n);

Copia el contenido de s2 a s1 hasta n elementos, (SSP), ROMaROM (Externa) Regresa: La dirección de s1

Función void *memmovepgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n);

Copia el contenido de s2 a s1 hasta n elementos, (SSP), ROMaRAM Regresa: La dirección de s1

Función MEM_MODEL rom void *memmoveram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n);

Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (SSP), RAMaROM (Externa) Regresa: La dirección de s1

Función void *memset (void *s, unsigned char c, size_t n); Copia el valor o carácter al arreglo RAM s hasta n veces. Regresa: La dirección de s

Función MEM_MODEL rom void *memsetpgm (MEM_MODEL rom void *s, unsigned char c, sizerom_t n);

Copia el valor o carácter al arreglo ROM (Externa) s hasta n veces. Regresa: La dirección de s

Función char *strcat (char *s1, const char *s2); Añade una copia la cadena s2 al final de s1, (NSP), RAMaRAM. Regresa: La dirección de s1

Función MEM_MODEL rom char *strcatpgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2);

Añade una copia la cadena s2 al final de s1, (NSP), ROMaROM (Externa) Regresa: La dirección de s1

Función char *strcatpgm2ram (char *s1, const MEM_MODEL rom char *s2); Añade una copia la cadena s2 al final de s1, (NSP), ROMaRAM. Regresa: La dirección de s1

Función MEM_MODEL rom char *strcatram2pgm (MEM_MODEL rom char *s1, const char *s2);

Añade una copia la cadena s2 al final de s1, (NSP), RAMaROM (Externa) Regresa: La dirección de s1

Función char *strchr (const char *s, unsigned char c); Busca el carácter c en la cadena RAM s Regresa: Puntero al carácter, en otro caso puntero nulo.

Función MEM_MODEL rom char *strchrpgm (const MEM_MODEL rom char *s, unsigned char c);

Busca el carácter c en la cadena ROM s Regresa: Puntero al carácter, en otro caso puntero nulo.

Función signed char strcmp (const char *s1, const char *s2); Compara el contenido de la cadena s1 y s2, RAMvsRAM Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char strcmppgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2);

Compara el contenido de la cadena s1 y s2, ROMvsROM Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char strcmppgm2ram (const char *s1, const MEM_MODEL rom char *s2);

Compara el contenido de la cadena s1 y s2, RAMvsROM Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char strcmpram2pgm (const MEM_MODEL rom char *s1, const char *s2);

Compara el contenido de la cadena s1 y s2, ROMvsRAM Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función char *strcpy (char *s1, const char *s2); Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP),


Revisión: 1.0 [07/2012] 31

RAMaRAM, Regresa: La dirección de s1

Función MEM_MODEL rom char *strcpypgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2);

Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), ROMaROM, Regresa: La dirección de s1

Función char *strcpypgm2ram (char *s1, const MEM_MODEL rom char *s2); Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), ROMaRAM, Regresa: La dirección de s1

Función MEM_MODEL rom char *strcpyram2pgm (MEM_MODEL rom char *s1, const char *s2);

Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), RAMaROM, Regresa: La dirección de s1

Función size_t strcspn (const char *s1, const char *s2); Calcula el numero consecutivo de caracteres de la cadena s1, que no se encuentran en la cadena s2, RAMaRAM Regresa: La posición del carácter (iniciando en cero)

Función sizerom_t strcspnpgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2);

Calcula el numero consecutivo de caracteres de la cadena s1, que no se encuentran en la cadena s2, ROMaROM Regresa: La posición del carácter (iniciando en cero)

Función sizerom_t strcspnpgmram (const MEM_MODEL rom char *s1, const char *s2);

Calcula el numero consecutivo de caracteres de la cadena s1, que no se encuentran en la cadena s2, ROMaRAM Regresa: La posición del carácter (iniciando en cero)

Función sizeram_t strcspnrampgm (const char *s1, const MEM_MODEL rom char *s2);

Calcula el numero consecutivo de caracteres de la cadena s1, que no se encuentran en la cadena s2, RAMaROM Regresa: La posición del carácter (iniciando en cero)

Función size_t strlen (const char *s); Calcula la longitud de la cadena s en RAM Regresa: La longitud en size_t

Función sizerom_t strlenpgm (const MEM_MODEL rom char *s); Calcula la longitud de la cadena s en ROM, Regresa: La longitud en sizerom_t

Función char *strlwr (char *s); Convierte todos los caracteres mayúsculas a minúsculas de una cadena s, RAM Regresa: La dirección de s

Función MEM_MODEL rom char *strlwrpgm (MEM_MODEL rom char *s); Convierte todos los caracteres mayúsculas a minúsculas de una cadena s ROM Regresa: La dirección de s

Función char *strupr (char *s); Convierte todos los caracteres minúsculas a mayúsculas de una cadena s, RAM Regresa: La dirección de s

Función MEM_MODEL rom char *struprpgm (MEM_MODEL rom char *s); Convierte todos los caracteres minúsculas a mayúsculas de una cadena s ROM Regresa: La dirección de s

Función char *strncat (char *s1, const char *s2, size_t n); Añade la cantidad especifica de caracteres de la Cadena s2 al final de s1, (NSP), RAMaRAM. Regresa: La dirección de s1

Función MEM_MODEL rom char *strncatpgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n);

Añade la cantidad especifica de caracteres de la Cadena s2 al final de s1, (NSP), RAMaROM. Regresa: La dirección de s1

Función char *strncatpgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n);

Añade la cantidad especifica de caracteres de la Cadena s2 al final de s1, (NSP), ROMaRAM. Regresa: La dirección de s1

Función MEM_MODEL rom char *strncatram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n);

Añade la cantidad especifica de caracteres de la Cadena s2 al final de s1, (NSP), ROMaROM. Regresa: La dirección de s1

Función signed char strncmp (const char *s1, const char *s2, size_t n); Compara el contenido de la cadena s1 y s2 hasta n caracteres, RAMvsRAM Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char strncmppgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n);

Compara el contenido de la cadena s1 y s2 hasta n caracteres, ROMvsROM Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char strncmppgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n);

Compara el contenido de la cadena s1 y s2 hasta n caracteres, RAMvsROM Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función signed char strncmpram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n);

Compara el contenido de la cadena s1 y s2 hasta n caracteres, ROMvsRAM Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2

Función char *strncpy (char *s1, const char *s2, size_t n); Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), RAMaRAM, Regresa: La dirección de s1

Función MEM_MODEL rom char *strncpypgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n);

Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), ROMaROM, Regresa: La dirección de s1

Función char *strncpypgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n);

Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), ROMaRAM, Regresa: La dirección de s1

Función MEM_MODEL rom char *strncpyram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n);

Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), RAMaROM, Regresa: La dirección de s1

Función char *strpbrk (const char *s1, const char *s2); Busca en la cadena s1 el primer carácter que se encuentre en s2, RAMaRAM Regresa: Puntero al carácter, o nulo si no encuentra.

Función MEM_MODEL rom char *strpbrkpgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2);

Busca en la cadena s1 el primer carácter que se encuentre en s2, ROMaROM Regresa: Puntero al carácter, o nulo si no encuentra.

Función MEM_MODEL rom char *strpbrkpgmram (const MEM_MODEL rom char *s1, const char *s2);

Busca en la cadena s1 el primer carácter que se encuentre en s2, ROMaRAM Regresa: Puntero al carácter, o nulo si no encuentra.

Función char *strpbrkrampgm (const char *s1, const MEM_MODEL rom char *s2);

Busca en la cadena s1 el primer carácter que se encuentre en s2, RAMaROM Regresa: Puntero al carácter, o nulo si no encuentra.

Función char *strrchr (const char *s, unsigned char c); Busca la última ocurrencia del carácter c en la cadena s, RAMyRAM Regresa: Puntero al carácter, en otro caso nulo.

Función size_t strspn (const char *s1, const char *s2); Calcula el número de caracteres en s2 que coinciden en s1, RAMaRAM Regresa: El número de caracteres similares desde el inicio.


Revisión: 1.0 [07/2012] 32

Función sizerom_t strspnpgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2);

Calcula el número de caracteres en s2 que coinciden en s1, ROMaROM Regresa: El número de caracteres similares desde el inicio.

Función sizerom_t strspnpgmram (const MEM_MODEL rom char *s1, const char *s2);

Calcula el número de caracteres en s2 que coinciden en s1, ROMaRAM Regresa: El número de caracteres similares desde el inicio.

Función sizeram_t strspnrampgm (const char *s1, const MEM_MODEL rom char *s2);

Calcula el número de caracteres en s2 que coinciden en s1, RAMaROM Regresa: El número de caracteres similares desde el inicio.

Función char *strstr (const char *s1, const char *s2); Localiza la subcadena s2 dentro de la cadena s1, RAMaRAM Regresa: Puntero a la cadena, en otro caso nulo

Función MEM_MODEL rom char *strstrpgm (auto const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2);

Localiza la subcadena s2 dentro de la cadena s1, ROMaROM Regresa: Puntero a la cadena, en otro caso nulo

Función MEM_MODEL rom char *strstrpgmram (const MEM_MODEL rom char *s1, const char *s2);

Localiza la subcadena s2 dentro de la cadena s1, ROMaRAM Regresa: Puntero a la cadena, en otro caso nulo

Función char *strstrrampgm (const char *s1, const MEM_MODEL rom char *s2);

Localiza la subcadena s2 dentro de la cadena s1, RAMaROM Regresa: Puntero a la cadena, en otro caso nulo

Función char *strtok (char *s1, const char *s2);

Divide una cadena s1 en subcadenas, remplazando los tokens de s2 por ‘\0’, uno por llamada, las siguientes llamadas debe ser s1 = NULO, RAMaRAM. Regresa: Puntero al primer carácter de la subcadena, cuando ya no encuentra delimitadores regresa NULO

Función MEM_MODEL rom char *strtokpgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2);

Divide una cadena s1 en subcadenas, remplazando los tokens de s2 por ‘\0’, uno por llamada, las siguientes llamadas debe ser s1 = NULO, ROMaROM. Regresa: Puntero al primer carácter de la subcadena, cuando ya no encuentra delimitadores regresa NULO

Función char *strtokpgmram (char *s1, const MEM_MODEL rom char *s2);

Divide una cadena s1 en subcadenas, remplazando los tokens de s2 por ‘\0’, uno por llamada, las siguientes llamadas debe ser s1 = NULO, RAMaROM. Regresa: Puntero al primer carácter de la subcadena, cuando ya no encuentra delimitadores regresa NULO

Función MEM_MODEL rom char *strtokrampgm (MEM_MODEL rom char *s1, const char *s2);

Divide una cadena s1 en subcadenas, remplazando los tokens de s2 por ‘\0’, uno por llamada, las siguientes llamadas debe ser s1 = NULO, ROMaRAM. Regresa: Puntero al primer carácter de la subcadena, cuando ya no encuentra delimitadores regresa NULO

14.1. Ejemplo con <string.h>

string.h

#ifndef __STRING_H #define __STRING_H #ifndef __STDDEF_H #include <stddef.h> #endif /* The compiler calling convention varies depending on the target * processor family; therefore, there often needs to be separate * prototypes depending on which compiler is being used. * * MPLAB-C18 provides the __18CXX environment variable which will * allow us to know that we're compiling for an 18c part. Future * versions of MPLAB-C17 will have a corresponding __17CXX environment * variable, but as of v2.30.03, it does not. * * Since the only two Microchip compilers currently available are * MPLAB-C17 and MPLAB-C18, the presence or absence of __18CXX * is sufficient to determine the target platform. */ #if __18CXX /* Change this to near (or omit altogether) if building small memory model * versions of the libraries */ #define MEM_MODEL far void *memcpy (auto void *s1, auto const void *s2, auto size_t n); void *memmove (auto void *s1, auto const void *s2, auto size_t n); char *strcpy (auto char *s1, auto const char *s2); char *strncpy (auto char *s1, auto const char *s2, auto size_t n); char *strcat (auto char *s1, auto const char *s2); char *strncat (auto char *s1, auto const char *s2, auto size_t n); signed char memcmp (auto const void *s1, auto const void *s2, auto size_t n); signed char strcmp (auto const char *s1, auto const char *s2); signed char strncmp (auto const char *s1, auto const char *s2, auto size_t n);


Revisión: 1.0 [07/2012] 33

void *memchr (auto const void *s, auto unsigned char c, auto size_t n); char *strchr (auto const char *s, auto unsigned char c); size_t strcspn (auto const char *s1, auto const char *s2); char *strpbrk (auto const char *s1, auto const char *s2); char *strrchr (auto const char *s, auto unsigned char c); size_t strspn (auto const char *s1, auto const char *s2); char *strstr (auto const char *s1, auto const char *s2); char *strtok (auto char *s1, auto const char *s2); void *memset (auto void *s, auto unsigned char c, auto size_t n); #define strerror(n) ((n),"") size_t strlen (auto const char *s); char *strupr (auto char *s); char *strlwr (auto char *s); MEM_MODEL rom void *memcpypgm (auto MEM_MODEL rom void *s1, auto const MEM_MODEL rom void *s2, auto sizerom_t n); void *memcpypgm2ram (auto void *s1, auto const MEM_MODEL rom void *s2, auto sizeram_t n); MEM_MODEL rom void *memcpyram2pgm (auto MEM_MODEL rom void *s1, auto const void *s2, auto sizeram_t n); MEM_MODEL rom void *memmovepgm (auto MEM_MODEL rom void *s1, auto const MEM_MODEL rom void *s2, auto sizerom_t n); void *memmovepgm2ram (auto void *s1, auto const MEM_MODEL rom void *s2, auto sizeram_t n); MEM_MODEL rom void *memmoveram2pgm (auto MEM_MODEL rom void *s1, auto const void *s2, auto sizeram_t n); MEM_MODEL rom char *strcpypgm (auto MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2); char *strcpypgm2ram (auto char *s1, auto const MEM_MODEL rom char *s2); MEM_MODEL rom char *strcpyram2pgm (auto MEM_MODEL rom char *s1, auto const char *s2); MEM_MODEL rom char *strncpypgm (auto MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2, auto sizerom_t n); char *strncpypgm2ram (auto char *s1, auto const MEM_MODEL rom char *s2, auto sizeram_t n); MEM_MODEL rom char *strncpyram2pgm (auto MEM_MODEL rom char *s1, auto const char *s2, auto sizeram_t n); MEM_MODEL rom char *strcatpgm (auto MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2); char *strcatpgm2ram (auto char *s1, auto const MEM_MODEL rom char *s2); MEM_MODEL rom char *strcatram2pgm (auto MEM_MODEL rom char *s1, auto const char *s2); MEM_MODEL rom char *strncatpgm (auto MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2, auto sizerom_t n); char *strncatpgm2ram (auto char *s1, auto const MEM_MODEL rom char *s2, auto sizeram_t n); MEM_MODEL rom char *strncatram2pgm (auto MEM_MODEL rom char *s1, auto const char *s2, auto sizeram_t n); signed char memcmppgm (auto MEM_MODEL rom void *s1, auto const MEM_MODEL rom void *s2, auto sizerom_t n); signed char memcmppgm2ram (auto void *s1, auto const MEM_MODEL rom void *s2, auto sizeram_t n); signed char memcmpram2pgm (auto MEM_MODEL rom void *s1, auto const void *s2, auto sizeram_t n); signed char strcmppgm (auto const MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2); signed char strcmppgm2ram (auto const char *s1, auto const MEM_MODEL rom char *s2); signed char strcmpram2pgm (auto const MEM_MODEL rom char *s1, auto const char *s2); signed char strncmppgm (auto const MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2, auto sizerom_t n); signed char strncmppgm2ram (auto char *s1, auto const MEM_MODEL rom char *s2, auto sizeram_t n); signed char strncmpram2pgm (auto MEM_MODEL rom char *s1, auto const char *s2, auto sizeram_t n); MEM_MODEL rom char *memchrpgm (auto const MEM_MODEL rom char *s, auto const unsigned char c, auto sizerom_t n); MEM_MODEL rom char *strchrpgm (auto const MEM_MODEL rom char *s, auto unsigned char c); sizerom_t strcspnpgm (auto const MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2); sizerom_t strcspnpgmram (auto const MEM_MODEL rom char *s1, auto const char *s2); sizeram_t strcspnrampgm (auto const char *s1, auto const MEM_MODEL rom char *s2); MEM_MODEL rom char *strpbrkpgm (auto const MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2); MEM_MODEL rom char *strpbrkpgmram (auto const MEM_MODEL rom char *s1, auto const char *s2); char *strpbrkrampgm (auto const char *s1, auto const MEM_MODEL rom char *s2); sizerom_t strspnpgm (auto const MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2); sizerom_t strspnpgmram (auto const MEM_MODEL rom char *s1, auto const char *s2); sizeram_t strspnrampgm (auto const char *s1, auto const MEM_MODEL rom char *s2); MEM_MODEL rom char *strstrpgm (auto const MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2); MEM_MODEL rom char *strstrpgmram (auto const MEM_MODEL rom char *s1, auto const char *s2); char *strstrrampgm (auto const char *s1, auto const MEM_MODEL rom char *s2); MEM_MODEL rom char *strtokpgm (auto MEM_MODEL rom char *s1, auto const MEM_MODEL rom char *s2); char *strtokpgmram (auto char *s1, auto const MEM_MODEL rom char *s2); MEM_MODEL rom char *strtokrampgm (auto MEM_MODEL rom char *s1, auto const char *s2); MEM_MODEL rom void *memsetpgm (auto MEM_MODEL rom void *s, auto unsigned char c, auto sizerom_t n); MEM_MODEL rom char *struprpgm (auto MEM_MODEL rom char *s); MEM_MODEL rom char *strlwrpgm (auto MEM_MODEL rom char *s); sizerom_t strlenpgm (auto const MEM_MODEL rom char *s); #undef MEM_MODEL #else void strcat (static char *, static char *); signed char strcmp (static char *, static char *); void strcpy (static char *, static char *); unsigned char strlen (static char *); void strlwr (static char *); void strupr (static char *); void strset (static char *, static char); #endif #endif


Revisión: 1.0 [07/2012] 34

main.c

#include <stdio.h> #include <string.h> void main(void) { char Cadena_RAM[] = "Hola mundo!!"; char Cadena2_RAM[] = "Hola software!!"; char CadDest_RAM[50]; char CadDest2_RAM[5]; static const far rom char Cadena_ROM[] = "Hola mundo!!"; static const far rom char Cadena2_ROM[] = "Hola c18!!"; char r; char *p; // void *memchr (const void *s, unsigned char c, size_t n); // Busca el byte c en la región de memoria RAM s hasta n bytes // Regresa: La posición del byte, en otro caso nulo. printf("01. El caracter %c esta en RAM: 0x%04P\n",'H',memchr((const char*)Cadena_RAM,'H',12)); printf("02. El caracter %c esta en RAM: 0x%04P\n",'a',memchr((const char*)Cadena_RAM,'a',12)); // MEM_MODEL rom char *memchrpgm (const MEM_MODEL rom char *s, const unsigned char c, sizerom_t n); // Busca el char c en la región de memoria ROM s hasta n bytes // Regresa: La posición del byte, en otro caso nulo. printf("03. El caracter %c esta en ROM: 0x%04HP\n",'H',memchrpgm(Cadena_ROM,'H',12)); printf("04. El caracter %c esta en ROM: 0x%04HP\n",'a',memchrpgm(Cadena_ROM,'a',12)); // signed char memcmp (const void *s1, const void *s2, size_t n); // Compara el contenido de dos arreglos de bytes RAM hasta n bytes. // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = memcmp((const char*)Cadena_RAM,(const char*)Cadena2_RAM,12); // Compara RAMvsRAM if (r < 0) printf("05. RAMvsRAM %s < %s\n",Cadena_RAM,Cadena2_RAM); else if (r > 0) printf("05. RAMvsRAM %s > %s\n",Cadena_RAM,Cadena2_RAM); else printf("05. RAMvsRAM %s = %s\n",Cadena_RAM,Cadena2_RAM); // signed char memcmppgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n); // Compara el contenido de dos arreglos d e bytes ROM hasta n bytes. // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = memcmppgm((far rom char*)Cadena_ROM,Cadena2_ROM,10); // Compara ROMvsROM if (r < 0) printf("06. ROMvsROM %HS < %HS\n",Cadena_ROM,Cadena2_ROM); else if (r > 0) printf("06. ROMvsROM %HS > %HS\n",Cadena_ROM,Cadena2_ROM); else printf("06. ROMvsROM %HS = %HS\n",Cadena_ROM,Cadena2_ROM); // signed char memcmppgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n); // Compara el contenido de dos arreglos de bytes RAMvsROM hasta n bytes. // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = memcmppgm2ram(Cadena_RAM,Cadena_ROM,12); // Compara RAMvsROM if (r < 0) printf("07. RAMvsROM %s < %HS\n",Cadena_RAM,Cadena_ROM); else if (r > 0) printf("07. RAMvsROM %s > %HS\n",Cadena_RAM,Cadena_ROM); else printf("07. RAMvsROM %s = %HS\n",Cadena_RAM,Cadena_ROM); // signed char memcmpram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n); // Compara el contenido de dos arreglos de bytes ROMvsRAM hasta n bytes. // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = memcmpram2pgm((far rom char*)Cadena_ROM,(const char*)Cadena_RAM,12); // Compara ROMvsRAM if (r < 0) printf("08. ROMvsRAM %HS < %s\n",Cadena_ROM,Cadena_RAM); else if (r > 0) printf("08. ROMvsRAM %HS > %s\n",Cadena_ROM,Cadena_RAM); else printf("08. ROMvsRAM %HS = %s\n",Cadena_ROM,Cadena_RAM); // void *memcpy (void *s1, const void *s2, size_t n); // Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (NSP), RAMaRAM // Regresa: La dirección de s1


Revisión: 1.0 [07/2012] 35

printf("09. Direccion de destino: 0x%P\n",memcpy(CadDest_RAM,(const char*)Cadena_RAM,20)); // Copiamos RAMaRAM printf("10. Origen: %s, Destino: %s\n",Cadena_RAM,CadDest_RAM); memcpy((char*)&CadDest_RAM+2,(const char*)CadDest_RAM,4); printf("11. Error por superposicion: %s\n",CadDest_RAM); // Error (NSP): No se soporta superposicion // M_MODEL rom void *memcpypgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n); // Copia el contenido de s2 a s1 hasta n elementos, (NSP), ROMaROM (Externa) // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // void *memcpypgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n); // Copia el contenido de s2 a s1 hasta n elementos, (NSP), ROMaRAM // Regresa: La dirección de s1 printf("12. Direccion de destino: 0x%P\n",memcpypgm2ram(CadDest_RAM,Cadena_ROM,20)); // Copiamos ROMaRAM printf("13. Origen: %HS, Destino: %s\n",Cadena_ROM,CadDest_RAM); // MEM_MODEL rom void *memcpyram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n); // Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (NSP), RAMaROM (Externa) // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // void *memmove (void *s1, const void *s2, size_t n); // Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (SSP), RAMaRAM // Regresa: La dirección de s1 printf("14. Direccion de destino: 0x%P\n",memmove(CadDest_RAM,(const char*)Cadena_RAM,20)); // Copiamos RAMaRAM printf("15. Origen: %s, Destino: %s\n",Cadena_RAM,CadDest_RAM); memmove((char*)&CadDest_RAM+2,(const char*)CadDest_RAM,4); printf("16. Soporta superposicion: %s\n",CadDest_RAM); // OK (SSP): Soporta superposicion // MEM_MODEL rom void *memmovepgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n); // Copia el contenido de s2 a s1 hasta n elementos, (SSP), ROMaROM (Externa) // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // void *memmovepgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n); // Copia el contenido de s2 a s1 hasta n elementos, (SSP), ROMaRAM // Regresa: La dirección de s1 printf("17. Direccion de destino: 0x%P\n",memmovepgm2ram(CadDest_RAM,Cadena_ROM,20)); // Copiamos ROMaRAM printf("18. Origen: %HS, Destino: %s\n",Cadena_ROM,CadDest_RAM); // MEM_MODEL rom void *memmoveram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n); // Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (SSP), RAMaROM // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // void *memset (void *s, unsigned char c, size_t n); // Copia el valor o carácter al arreglo RAM s hasta n veces. // Regresa: La dirección de s CadDest_RAM[19]='\0'; printf("19. Dir dest: 0x%04P, Cadena llena de %c: %s\n",memset(CadDest_RAM,'X',19),'X',CadDest_RAM); // MEM_MODEL rom void *memsetpgm (MEM_MODEL rom void *s, unsigned char c, sizerom_t n); // Copia el valor o carácter al arreglo ROM (Externa) s hasta n veces. // Regresa: La dirección de s // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strcat (char *s1, const char *s2); // Anade una copia la cadena s2 al final de s1, (NSP), RAMaRAM. // Regresa: La dirección de s1 memcpy(CadDest_RAM,(const char*)Cadena_RAM,13); strcat(CadDest_RAM,(const char*)Cadena_RAM); printf("20. La cadena doble es: %s\n",CadDest_RAM); // MEM_MODEL rom char *strcatpgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); // Anade una copia la cadena s2 al final de s1, (NSP), ROMaROM (Externa) // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strcatpgm2ram (char *s1, const MEM_MODEL rom char *s2); // Anade una copia la cadena s2 al final de s1, (NSP), ROMaRAM. // Regresa: La dirección de s1 memcpy(CadDest_RAM,(const char*)Cadena_RAM,13); strcatpgm2ram(CadDest_RAM,(const far rom char*)", Cadena 2 de ROM anadida!!"); printf("21. La cadena es: %s\n",CadDest_RAM); // MEM_MODEL rom char *strcatram2pgm (MEM_MODEL rom char *s1, const char *s2); // Anade una copia la cadena s2 al final de s1, (NSP), RAMaROM (Externa)


Revisión: 1.0 [07/2012] 36

// Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strchr (const char *s, unsigned char c); // Busca el caracter c en la cadena RAM s // Regresa: Puntero al caracter, en otro caso puntero nulo. printf("22. El primer caracter %c esta en la posicion RAM: 0x%04P\n",'!',strchr(Cadena_RAM,'!')); // MEM_MODEL rom char *strchrpgm (const MEM_MODEL rom char *s, unsigned char c); // Busca el caracter c en la cadena ROM s // Regresa: Puntero al caracter, en otro caso puntero nulo. printf("23. El primer caracter %c esta en la posicion ROM: 0x%04HP\n",'!',strchrpgm(Cadena_ROM,'!')); // signed char strcmp (const char *s1, const char *s2); // Compara el contenido de la cadena s1 y s2, RAMvsRAM // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = strcmp(Cadena_RAM,Cadena2_RAM); // Compara RAMvsRAM if (r < 0) printf("24. RAMvsRAM %s < %s\n",Cadena_RAM,Cadena2_RAM); else if (r > 0) printf("24. RAMvsRAM %s > %s\n",Cadena_RAM,Cadena2_RAM); else printf("24. RAMvsRAM %s = %s\n",Cadena_RAM,Cadena2_RAM); // signed char strcmppgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); // Compara el contenido de la cadena s1 y s2, ROMvsROM // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = strcmppgm(Cadena_ROM,Cadena2_ROM); // Compara RAMvsRAM if (r < 0) printf("25. ROMvsROM %HS < %HS\n",Cadena_ROM,Cadena2_ROM); else if (r > 0) printf("25. ROMvsROM %HS > %HS\n",Cadena_ROM,Cadena2_ROM); else printf("25. ROMvsROM %HS = %HS\n",Cadena_ROM,Cadena2_ROM); // signed char strcmppgm2ram (const char *s1, const MEM_MODEL rom char *s2); // Compara el contenido de la cadena s1 y s2, RAMvsROM // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = strcmppgm2ram(Cadena_RAM,Cadena2_ROM); // Compara RAMvsROM if (r < 0) printf("26. RAMvsROM %s < %HS\n",Cadena_RAM,Cadena2_ROM); else if (r > 0) printf("26. RAMvsROM %s > %HS\n",Cadena_RAM,Cadena2_ROM); else printf("26. RAMvsROM %s = %HS\n",Cadena_RAM,Cadena2_ROM); // signed char strcmpram2pgm (const MEM_MODEL rom char *s1, const char *s2); // Compara el contenido de la cadena s1 y s2, ROMvsRAM // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = strcmpram2pgm(Cadena2_ROM,Cadena_RAM); // Compara ROMvsRAM if (r < 0) printf("27. ROMvsRAM %HS < %s\n",Cadena2_ROM,Cadena_RAM); else if (r > 0) printf("27. ROMvsRAM %HS > %s\n",Cadena2_ROM,Cadena_RAM); else printf("27. ROMvsRAM %HS = %s\n",Cadena2_ROM,Cadena_RAM); // char *strcpy (char *s1, const char *s2); // Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), RAMaRAM // Regresa: La dirección de s1 strcpy(CadDest_RAM,Cadena_RAM); printf("28. La cadena es: %s\n",CadDest_RAM); // MEM_MODEL rom char *strcpypgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); // Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), ROMaROM // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strcpypgm2ram (char *s1, const MEM_MODEL rom char *s2); // Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), ROMaRAM // Regresa: La dirección de s1 strcpypgm2ram(CadDest_RAM,Cadena2_ROM); printf("29. La cadena es: %s\n",CadDest_RAM); // MEM_MODEL rom char *strcpyram2pgm (MEM_MODEL rom char *s1, const char *s2); // Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), RAMaROM // Regresa: La dirección de s1


Revisión: 1.0 [07/2012] 37

// No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // size_t strcspn (const char *s1, const char *s2); // Calcula el número consecutivo de caracteres de la cadena s1, que no se encuentran en la cadena s2, RAMaRAM // Regresa: La posición del carácter (iniciando en cero) strcpypgm2ram(CadDest_RAM,"aeiou"); printf("30. Se encontro algun caracter de \"aeiou\" en la posicion: %i\n",strcspn(Cadena_RAM,CadDest_RAM)); // sizerom_t strcspnpgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); // Calcula el número consecutivo de caracteres de la cadena s1, que no se encuentran en la cadena s2, ROMaROM // Regresa: La posición del carácter (iniciando en cero) printf("31. Se encontro algun caracter de \"aeiou\" en la posicion: %Hp\n",strcspnpgm(Cadena_ROM,"aeiou")); // sizerom_t strcspnpgmram (const MEM_MODEL rom char *s1, const char *s2); // Calcula el número consecutivo de caracteres de la cadena s1, que no se encuentran en la cadena s2, ROMaRAM // Regresa: La posición del carácter (iniciando en cero) strcpypgm2ram(CadDest_RAM,"aeiou"); printf("32. Se encontro algun caracter de \"aeiou\" en la posicion: %Hp\n",strcspnpgmram(Cadena_ROM,CadDest_RAM)); // sizeram_t strcspnrampgm (const char *s1, const MEM_MODEL rom char *s2); // Calcula el número consecutivo de caracteres de la cadena s1, que no se encuentran en la cadena s2, RAMaROM // Regresa: La posición del carácter (iniciando en cero) printf("33. Se encontro algun caracter de \"aeiou\" en la posicion: %p\n",strcspnrampgm(Cadena_RAM,"aeiou")); // size_t strlen (const char *s); // Calcula la longitud de la cadena s en RAM // Regresa: La longuitud en size_t printf("34. La cadena en RAM: %s, tiene longuitud: %u\n",Cadena_RAM,strlen(Cadena_RAM)); // sizerom_t strlenpgm (const MEM_MODEL rom char *s); // Calcula la longitud de la cadena s en ROM // Regresa: La longuitud en sizerom_t printf("35. La cadena en ROM: %HS, tiene longuitud: %Hu\n",Cadena_ROM,strlenpgm(Cadena_ROM)); // char *strlwr (char *s); // Convierte todos los caracteres mayúsculas a minúsculas de una cadena s // Regresa: La dirección de s strcpypgm2ram(CadDest_RAM,"HOLA MUNDO!!, 0123456789"); strlwr(CadDest_RAM); printf("36. La cadena en minusculas RAM es: %s\n",CadDest_RAM); // MEM_MODEL rom char *strlwrpgm (MEM_MODEL rom char *s); // Convierte todos los caracteres mayúsculas a minúsculas de una cadena s ROM // Regresa: La dirección de s // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strupr (char *s); // Convierte todos los caracteres minúsculas a mayúsculas de una cadena s, RAM // Regresa: La dirección de s strcpypgm2ram(CadDest_RAM,"HOLA MUNDO!!, 0123456789"); strupr(CadDest_RAM); printf("37. La cadena en minusculas RAM es: %s\n",CadDest_RAM); // MEM_MODEL rom char *struprpgm (MEM_MODEL rom char *s); // Convierte todos los caracteres minúsculas a mayúsculas de una cadena s ROM // Regresa: La dirección de s // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strncat (char *s1, const char *s2, size_t n); // Añade la cantidad específica de caracteres de la Cadena s2 al final de s1, (NSP), RAMaRAM. // Regresa: La dirección de s1 strcpy(CadDest_RAM,Cadena_RAM); strncat(CadDest_RAM,Cadena_RAM,4); printf("38. La cadena es: %s\n",CadDest_RAM); // MEM_MODEL rom char *strncatpgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n); // Añade la cantidad específica de caracteres de la Cadena s2 al final de s1, (NSP), RAMaROM. // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // -----------------BUG--------------------- // char *strncatpgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n); // Añade la cantidad específica de caracteres de la Cadena s2 al final de s1, (NSP), ROMaRAM. // Regresa: La dirección de s1 strcpy(CadDest_RAM,Cadena_RAM); strncatpgm2ram(CadDest_RAM,"1234567890",3); //CadDest_RAM[15]='\0';


Revisión: 1.0 [07/2012] 38

printf("39. La cadena hasta 3 es: %s\n",CadDest_RAM); // MEM_MODEL rom char *strncatram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n); // Añade la cantidad específica de caracteres de la Cadena s2 al final de s1, (NSP), ROMaROM. // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // signed char strncmp (const char *s1, const char *s2, size_t n); // Compara el contenido de la cadena s1 y s2 hasta n caracteres, RAMvsRAM // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = strncmp(Cadena_RAM,Cadena2_RAM,4); if (r < 0) printf("40. RAMvsRAM 4 carac: %s < %s\n",Cadena_RAM,Cadena2_RAM); else if (r > 0) printf("40. RAMvsRAM 4 carac: %s > %s\n",Cadena_RAM,Cadena2_RAM); else printf("40. RAMvsRAM 4 carac: %s = %s\n",Cadena_RAM,Cadena2_RAM); // signed char strncmppgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n); // Compara el contenido de la cadena s1 y s2 hasta n caracteres, ROMvsROM // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = strncmppgm(Cadena_ROM,Cadena2_ROM,4); if (r < 0) printf("41. ROMvsROM 4 carac: %HS < %HS\n",Cadena_ROM,Cadena2_ROM); else if (r > 0) printf("41. ROMvsROM 4 carac: %HS > %HS\n",Cadena_ROM,Cadena2_ROM); else printf("41. ROMvsROM 4 carac: %HS = %HS\n",Cadena_ROM,Cadena2_ROM); // signed char strncmppgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n); // Compara el contenido de la cadena s1 y s2 hasta n caracteres, RAMvsROM // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = strncmppgm2ram(Cadena_RAM,Cadena2_ROM,6); if (r < 0) printf("42. RAMvsROM 6 carac: %s < %HS\n",Cadena_RAM,Cadena2_ROM); else if (r > 0) printf("42. RAMvsROM 6 carac: %s > %HS\n",Cadena_RAM,Cadena2_ROM); else printf("42. RAMvsROM 6 carac: %s = %HS\n",Cadena_RAM,Cadena2_ROM); // signed char strncmpram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n); // Compara el contenido de la cadena s1 y s2 hasta n caracteres, ROMvsRAM // Regresa: <0 si s1 es menor a s2, 0 si son iguales, >0 si s1 es mayor a s2 r = strncmpram2pgm((far rom char*)Cadena2_ROM,Cadena_RAM,6); if (r < 0) printf("43. ROMvsRAM 6 carac: %HS < %s\n",Cadena2_ROM,Cadena_RAM); else if (r > 0) printf("43. ROMvsRAM 6 carac: %HS > %s\n",Cadena2_ROM,Cadena_RAM); else printf("43. ROMvsRAM 6 carac: %HS = %s\n",Cadena2_ROM,Cadena_RAM); // char *strncpy (char *s1, const char *s2, size_t n); // Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), RAMaRAM // Regresa: La dirección de s1 strncpy(CadDest_RAM,Cadena2_RAM,4); CadDest_RAM[4]='\0'; // Si no hay carácter nulo en los n no se añade automáticamente printf("44. La cadena: %s en RAM, hasta 4 caract. es: %s\n",Cadena_RAM,CadDest_RAM); // MEM_MODEL rom char *strncpypgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n); // Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), ROMaROM // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strncpypgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n); // Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), ROMaRAM // Regresa: La dirección de s1 strncpypgm2ram(CadDest_RAM,Cadena_ROM,4); CadDest_RAM[4]='\0'; // Si no hay carácter nulo en los n no se añade automáticamente printf("45. La cadena: %HS en ROM, hasta 4 caract. es: %s\n",Cadena_ROM,CadDest_RAM); // MEM_MODEL rom char *strncpyram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n); // Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), RAMaROM // Regresa: La dirección de s1 // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strpbrk (const char *s1, const char *s2); // Busca en la cadena s1 el primer carácter que se encuentre en s2, RAMaRAM


Revisión: 1.0 [07/2012] 39

// Regresa: Puntero al carácter, o nulo si no encuentra. strcpypgm2ram(CadDest_RAM,"aeiou"); printf("46. Cadena: %s, Buscar: %s, Inicio: 0x%04P, Encontrado: 0x%04P \n",Cadena_RAM,CadDest_RAM,&Cadena_RAM,strpbrk(Cadena_RAM,CadDest_RAM)); // MEM_MODEL rom char *strpbrkpgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); // Busca en la cadena s1 el primer carácter que se encuentre en s2, ROMaROM // Regresa: Puntero al carácter, o nulo si no encuentra. printf("47. Cadena: %HS, Buscar: aeiou, Inicio: 0x%04HP, Encontrado: 0x%04HP \n",Cadena_ROM,&Cadena_ROM,strpbrkpgm(Cadena_ROM,"aeiou")); // MEM_MODEL rom char *strpbrkpgmram (const MEM_MODEL rom char *s1, const char *s2); // Busca en la cadena s1 el primer carácter que se encuentre en s2, ROMaRAM // Regresa: Puntero al carácter, o nulo si no encuentra. strcpypgm2ram(CadDest_RAM,"aeiou"); printf("48. Cadena: %HS, Buscar: %s, Inicio: 0x%04HP, Encontrado: 0x%04HP \n",Cadena_ROM,CadDest_RAM,&Cadena_ROM,strpbrkpgmram(Cadena_ROM,CadDest_RAM)); // char *strpbrkrampgm (const char *s1, const MEM_MODEL rom char *s2); // Busca en la cadena s1 el primer carácter que se encuentre en s2, RAMaROM // Regresa: Puntero al carácter, o nulo si no encuentra. printf("49. Cadena: %s, Buscar: %HS, Inicio: 0x%04P, Encontrado: 0x%04P \n",Cadena_RAM,"aeiou",&Cadena_RAM,strpbrkrampgm(Cadena_RAM,"aeiou")); // char *strrchr (const char *s, unsigned char c); // Busca la ultima ocurrencia del carácter c en la cadena s, RAMyRAM // Regresa: Puntero al carácter, en otro caso nulo. printf("50. La cadena: %s, Inicio: 0x%04p, Ultima ocurrencia en: 0x%04p\n",Cadena_RAM,&Cadena_RAM,strrchr(Cadena_RAM,'!')); // size_t strspn (const char *s1, const char *s2); // Calcula el número de caracteres en s2 que coinciden en s1, RAMaRAM // Regresa: El número de caracteres similares desde el inicio. strcpypgm2ram(CadDest_RAM,"Holo mundo!!"); printf("51. La cadena: %s, de: %s, Tiene: %u\n",Cadena_RAM,CadDest_RAM,strspn(Cadena_RAM,CadDest_RAM)); // sizerom_t strspnpgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); // Calcula el número de caracteres en s2 que coinciden en s1, ROMaROM // Regresa: El número de caracteres similares desde el inicio. printf("52. La cadena: %HS, de: %HS, Tiene: %Hu\n",Cadena_ROM,"Holo mundo!!",strspnpgm(Cadena_ROM,"Holo mundo!!")); // sizerom_t strspnpgmram (const MEM_MODEL rom char *s1, const char *s2); // Calcula el número de caracteres en s2 que coinciden en s1, ROMaRAM // Regresa: El número de caracteres similares desde el inicio. strcpypgm2ram(CadDest_RAM,"Holo mundo!!"); printf("53. La cadena: %HS, de: %s, Tiene: %Hu\n",Cadena_ROM,CadDest_RAM,strspnpgmram(Cadena_ROM,CadDest_RAM)); // sizeram_t strspnrampgm (const char *s1, const MEM_MODEL rom char *s2); // Calcula el número de caracteres en s2 que coinciden en s1, RAMaROM // Regresa: El número de caracteres similares desde el inicio. printf("54. La cadena: %s, de: %HS, Tiene: %u\n",Cadena_RAM,"Holo mundo!!",strspnrampgm(Cadena_RAM,"Holo mundo!!")); // char *strstr (const char *s1, const char *s2); // Localiza la subcadena s2 dentro de la cadena s1, RAMaRAM // Regresa: Puntero a la cadena, en otro caso nulo strcpypgm2ram(CadDest_RAM,"mundo"); printf("55. Cadena: %s, Subcadena: %s, Inicio: 0x%04P, Posicion: 0x%04P\n",Cadena_RAM,CadDest_RAM,&Cadena_RAM,strstr(Cadena_RAM,CadDest_RAM)); // MEM_MODEL rom char *strstrpgm (auto const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); // Localiza la subcadena s2 dentro de la cadena s1, ROMaROM // Regresa: Puntero a la cadena, en otro caso nulo printf("56. Cadena: %HS, Subcadena: %HS, Inicio: 0x%04HP, Posicion: 0x%04HP\n",Cadena_ROM,"mundo",&Cadena_ROM,strstrpgm(Cadena_ROM,"mundo")); // MEM_MODEL rom char *strstrpgmram (const MEM_MODEL rom char *s1, const char *s2); // Localiza la subcadena s2 dentro de la cadena s1, ROMaRAM // Regresa: Puntero a la cadena, en otro caso nulo strcpypgm2ram(CadDest_RAM,"mundo"); printf("57. Cadena: %HS, Subcadena: %s, Inicio: 0x%04HP, Posicion: 0x%04HP\n",Cadena_ROM,CadDest_RAM,&Cadena_ROM,strstrpgmram(Cadena_ROM,CadDest_RAM)); // char *strstrrampgm (const char *s1, const MEM_MODEL rom char *s2); // Localiza la subcadena s2 dentro de la cadena s1, RAMaROM // Regresa: Puntero a la cadena, en otro caso nulo printf("58. Cadena: %s, Subcadena: %HS, Inicio: 0x%04P, Posicion: 0x%04P\n",Cadena_RAM,"mundo",&Cadena_RAM,strstrrampgm(Cadena_RAM,"mundo"));


Revisión: 1.0 [07/2012] 40

// char *strtok (char *s1, const char *s2); // Divide una cadena s1 en subcadenas, remplazando los tokens de s2 por ‘\0’, uno por llamada, las siguientes llamadas debe ser s1 = NULO, RAMaRAM. // Regresa: Puntero al primer carácter de la subcadena, cuando ya no encuentra delimitadores regresa NULO strcpypgm2ram(CadDest_RAM,"Test1 Test2 Test3 Test4 Test5"); // Cadena a separar en subcadenas strcpypgm2ram(CadDest2_RAM," "); p = strtok(CadDest_RAM,CadDest2_RAM); // Primer llamada s1 = Cadena a separar y los tokens printf("59. Subcadenas: "); while (p != NULL){ // Mientras no regrese nulo printf("0x%04P=%s ",p,p); // Mostramos la subcadena p = strtok(NULL,CadDest2_RAM); // Siguientes llamadas con s1 = NULO para que separe la siguiente subcadena }; printf("\n"); // MEM_MODEL rom char *strtokpgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); // Divide una cadena s1 en subcadenas, remplazando los tokens de s2 por ‘\0’, uno por llamada, las siguientes llamadas debe ser s1 = NULO, ROMaROM. // Regresa: Puntero al primer carácter de la subcadena, cuando ya no encuentra delimitadores regresa NULO // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. // char *strtokpgmram (char *s1, const MEM_MODEL rom char *s2); // Divide una cadena s1 en subcadenas, remplazando los tokens de s2 por ‘\0’, uno por llamada, las siguientes llamadas debe ser s1 = NULO, RAMaROM. // Regresa: Puntero al primer carácter de la subcadena, cuando ya no encuentra delimitadores regresa NULO strcpypgm2ram(CadDest_RAM,"Test1 Test2 Test3 Test4 Test5"); // Cadena a separar en subcadenas p = strtokpgmram(CadDest_RAM," "); // Primer llamada s1 = Cadena a separar y los tokens printf("60. Subcadenas: "); while (p != NULL){ // Mientras no regrese nulo printf("0x%04P=%s ",p,p); // Mostramos la subcadena p = strtokpgmram(NULL," "); // Siguientes llamadas con s1 = NULO para que separe la siguiente subcadena }; printf("\n"); // MEM_MODEL rom char *strtokrampgm (MEM_MODEL rom char *s1, const char *s2); // Divide una cadena s1 en subcadenas, remplazando los tokens de s2 por ‘\0’, uno por llamada, las siguientes llamadas debe ser s1 = NULO, ROMaRAM. // Regresa: Puntero al primer carácter de la subcadena, cuando ya no encuentra delimitadores regresa NULO // No se puede realizar este ejemplo ya que se requiere de una memoria de Programa externa. } 01. El caracter H esta en RAM: 0x0301 02. El caracter a esta en RAM: 0x0304 03. El caracter H esta en ROM: 0x4BF4 04. El caracter a esta en ROM: 0x4BF7 05. RAMvsRAM Hola mundo!! < Hola software!! 06. ROMvsROM Hola mundo!! > Hola c18!! 07. RAMvsROM Hola mundo!! = Hola mundo!! 08. ROMvsRAM Hola mundo!! = Hola mundo!! 09. Direccion de destino: 0x31E 10. Origen: Hola mundo!!, Destino: Hola mundo!! 11. Error por superposicion: HoHoHoundo!! 12. Direccion de destino: 0x31E 13. Origen: Hola mundo!!, Destino: Hola mundo!! 14. Direccion de destino: 0x31E 15. Origen: Hola mundo!!, Destino: Hola mundo!! 16. Soporta superposicion: HoHolaundo!! 17. Direccion de destino: 0x31E 18. Origen: Hola mundo!!, Destino: Hola mundo!! 19. Dir dest: 0x031E, Cadena llena de X: XXXXXXXXXXXXXXXXXXX 20. La cadena doble es: Hola mundo!!Hola mundo!! 21. La cadena es: Hola mundo!!, Cadena 2 de ROM anadida!! 22. El primer caracter ! esta en la posicion RAM: 0x030B 23. El primer caracter ! esta en la posicion ROM: 0x4BFE 24. RAMvsRAM Hola mundo!! < Hola software!! 25. ROMvsROM Hola mundo!! > Hola c18!! 26. RAMvsROM Hola mundo!! > Hola c18!! 27. ROMvsRAM Hola c18!! < Hola mundo!! 28. La cadena es: Hola mundo!! 29. La cadena es: Hola c18!! 30. Se encontro algun caracter de "aeiou" en la posicion: 1 31. Se encontro algun caracter de "aeiou" en la posicion: 1 32. Se encontro algun caracter de "aeiou" en la posicion: 1 33. Se encontro algun caracter de "aeiou" en la posicion: 1 34. La cadena en RAM: Hola mundo!!, tiene longuitud: 12 35. La cadena en ROM: Hola mundo!!, tiene longuitud: 12 36. La cadena en minusculas RAM es: hola mundo!!, 0123456789 37. La cadena en minusculas RAM es: HOLA MUNDO!!, 0123456789 38. La cadena es: Hola mundo!!Hola


Revisión: 1.0 [07/2012] 41

39. La cadena hasta 3 es: Hola mundo!!123a 40. RAMvsRAM 4 carac: Hola mundo!! = Hola software!! 41. ROMvsROM 4 carac: Hola mundo!! = Hola c18!! 42. RAMvsROM 6 carac: Hola mundo!! > Hola c18!! 43. ROMvsRAM 6 carac: Hola c18!! < Hola mundo!! 44. La cadena: Hola mundo!! en RAM, hasta 4 caract. es: Hola 45. La cadena: Hola mundo!! en ROM, hasta 4 caract. es: Hola 46. Cadena: Hola mundo!!, Buscar: aeiou, Inicio: 0x0301, Encontrado: 0x0302 47. Cadena: Hola mundo!!, Buscar: aeiou, Inicio: 0x4BF4, Encontrado: 0x4BF5 48. Cadena: Hola mundo!!, Buscar: aeiou, Inicio: 0x4BF4, Encontrado: 0x4BF5 49. Cadena: Hola mundo!!, Buscar: aeiou, Inicio: 0x0301, Encontrado: 0x0302 50. La cadena: Hola mundo!!, Inicio: 0x0301, Ultima ocurrencia en: 0x030c 51. La cadena: Hola mundo!!, de: Holo mundo!!, Tiene: 3 52. La cadena: Hola mundo!!, de: Holo mundo!!, Tiene: 3 53. La cadena: Hola mundo!!, de: Holo mundo!!, Tiene: 3 54. La cadena: Hola mundo!!, de: Holo mundo!!, Tiene: 3 55. Cadena: Hola mundo!!, Subcadena: mundo, Inicio: 0x0301, Posicion: 0x0306 56. Cadena: Hola mundo!!, Subcadena: mundo, Inicio: 0x4BF4, Posicion: 0x4BF9 57. Cadena: Hola mundo!!, Subcadena: mundo, Inicio: 0x4BF4, Posicion: 0x4BF9 58. Cadena: Hola mundo!!, Subcadena: mundo, Inicio: 0x0301, Posicion: 0x0306 59. Subcadenas: 0x031E=Test1 0x0324=Test2 0x032A=Test3 0x0330=Test4 0x0336=Test5 60. Subcadenas: 0x031E=Test1 0x0324=Test2 0x032A=Test3 0x0330=Test4 0x0336=Test5


Revisión: 1.0 [07/2012] 42

15. Librería <timer.h>

Esta librería se utiliza para administrar la hora y fecha del sistema, pero como todos sabemos los MCU no tiene

estas funciones por lo que en C18 no está implementado.

16. Librería <delays.h>

Esta librería se utiliza para generar retardos en la ejecución del programa. No forma parte del ANSI pero es muy

útil.

El retardo está determinado por la siguiente formula:

Donde: 1TCY = Tiempo en segundos en ejecutar 1xTCY.

Fosc = Frecuencia del oscilador en Hz.

Ejemplo:

Si se utiliza un oscilador de 48Mhz, entonces 1TCY = 4/48Mhz = 83.33ns, esto quiere decir que cada TCY que se

ejecute consumirá 83.33ns. Si deseamos generar un delay de 500ms entonces: 500ms/83.33ns = 6,000,240 x 1TCY



Macro #define Delay1TCY() Nop() Retardo de 1xTCY

Función void Delay10TCYx(unsigned char unit); Retardo en múltiples de 10xTCY unit = 0, 2,560xTCY

Función void Delay100TCYx(unsigned char unit); Retardo en múltiples de 100xTCY unit = 0, 25,600xTCY

Función void Delay1KTCYx(unsinged char unit); Retardo en múltiples de 1KxTCY unit = 0, 256,000xTCY

Función void Delay10KTCYx(unsigned char unit); Retardo en múltiples de 10KxTCY unit = 0, 2,560,000xTCY

16.1. Ejemplo con <delays.h>

delays.h

#ifndef __DELAYS_H #define __DELAYS_H /* PIC18 cycle-count delay routines. * * Functions: * Delay1TCY() * Delay10TCY() // 17Cxx only * Delay10TCYx() * Delay100TCYx() * Delay1KTCYx() * Delay10KTCYx() */


Revisión: 1.0 [07/2012] 43

/* For definition of Nop() */ #include <p18cxxx.h> /* Delay of exactly 1 Tcy */ #define Delay1TCY() Nop() #define PARAM_SCLASS auto /* Delay of exactly 10 Tcy */ #define Delay10TCY() Delay10TCYx(1) /* Delay10TCYx * Delay multiples of 10 Tcy * Passing 0 (zero) results in a delay of 2560 cycles. * The 18Cxxx version of this function supports the full range [0,255] * The 17Cxxx version supports [2,255] and 0. */ void Delay10TCYx(PARAM_SCLASS unsigned char); /* Delay100TCYx * Delay multiples of 100 Tcy * Passing 0 (zero) results in a delay of 25,600 cycles. * The full range of [0,255] is supported. */ void Delay100TCYx(PARAM_SCLASS unsigned char); /* Delay1KTCYx * Delay multiples of 1000 Tcy * Passing 0 (zero) results in a delay of 256,000 cycles. * The full range of [0,255] is supported. */ void Delay1KTCYx(PARAM_SCLASS unsigned char); /* Delay10KTCYx * Delay multiples of 10,000 Tcy * Passing 0 (zero) results in a delay of 2,560,000 cycles. * The full range of [0,255] is supported. */ void Delay10KTCYx(PARAM_SCLASS unsigned char); #endif

main.c

#include <delays.h> void main(void) { // Con Fosc = 48MHz Delay1TCY(); // Retardo de 1xTCY = 83.33ns Delay10TCYx(120); // Retardo de 120x10xTCY = 120us Delay100TCYx(120); // Retardo de x100xTCY = 1ms Delay1KTCYx(120); // Retardo de x1KxTCY = 10ms Delay10KTCYx(120); // Retardo de x10KxTCY = 100ms }


Revisión: 1.0 [07/2012] 44

17. Librería <reset.h>

Esta librería es utilizada para determinar la causa que genero un evento de reset o wakeup en el microcontrolador.

A pesar de que no forma parte de ANSI C, es bueno saber que C18 cuenta con esta librería para manejar

interrupciones.



Macro WDT_ENABLED Habilita el uso de las funciones isWDTTO(); y isWDTWU(); Macro STVR_ENABLED Permite que se genere el evento reset cuando hay un desbordamiento.

Funcion char isBOR(void); Determina si la causa del reset fue Brown-Out Regresa: 1 si fue la causa, en otro caso 0

Funcion char isLVD(void); Determina si la causa del reset fue Low-Voltage detect Regresa: 1 si fue la causa, en otro caso 0

Funcion char isMCLR(void); Determina si la causa del reset fue el pin /MCLR Regresa: 1 si fue la causa, en otro caso 0

Funcion char isPOR(void); Determina si la causa del reset fue Power-on Reset Regresa: 1 si fue la causa, en otro caso 0

Funcion char isWDTTO(void); Determina si la causa del reset fue el timer del Watchdog. Regresa: 1 si fue la causa, en otro caso 0

Funcion char isWDTWU(void); Determina si la causa del wake-up fue el Watchdog timer Regresa: 1 si fue la causa, en otro caso 0

Funcion char isWU(void); Determina si la causa del wake-up fue del /MCLR o interrupción Regresa: 1 si fue la causa, en otro caso 0

Funcion void StatusReset(void); Esta función pone los bits POR y BOR del registro CPUSTA. Estos bits deben configurados después de un Power-On reset.

reset.h

/* $Id: reset.h,v 1.5 2008/12/19 08:33:30 jagadish Exp $ */ #ifndef __RESET_H #define __RESET_H #include <pconfig.h> /* PIC18 Reset-related operations */ #define WDT_ENABLED #define STVR_ENABLED /*Stack Over/ Under flow reset enable control */ #if defined(BOR_V1) #define BOR_ENABLED #endif char isMCLR(void); /* MCLR reset? */ void StatusReset(void); /* Reset the POR and BOR bits */ char isPOR(void); /* POR reset? */ char isWU(void); /* Wakeup during sleep? */ #if defined(BOR_ENABLED) char isBOR(void); /* BOR reset? */ #endif #if defined(WDT_ENABLED) char isWDTTO(void); /* WDT timeout during operation? */ char isWDTWU(void); /* WDT timeout during sleep? */ #endif #if defined (LVD_V1) char isLVD(void); /*LVD-- Low voltage detect? */ #endif #endif /* __RESET_H */


Revisión: 1.0 [07/2012] 45

18. Tabla ASCII


Revisión: 1.0 [07/2012] 46

19. REFERENCIAS

Eric Huss, “The C Library Reference Guide”, 1997

http://www.acm.uiuc.edu/webmonkeys/book/c_guide/

http://c.conclase.net, “Biblioteca ANSI C”, 2007

http://c.conclase.net/librerias/

“The ASCII code”, 2012

http://www.theasciicode.com.ar/

“Table of ASCII Characters”, 2012

http://www.docstoc.com/docs/70706928/Table-of-ASCII-Characters

Microchip, “MPLAB C18 COMPILER LIBRARIES”, 2005

http://ww1.microchip.com/downloads/en/devicedoc/mplab_c18_libraries_51297f.pdf

http://www.acm.uiuc.edu/webmonkeys/book/c_guide/

http://c.conclase.net/librerias/

http://www.theasciicode.com.ar/

http://www.docstoc.com/docs/70706928/Table-of-ASCII-Characters

http://ww1.microchip.com/downloads/en/devicedoc/mplab_c18_libraries_51297f.pdf

http://www.proprojects.wordpress.com

MPLAB C18: Librerias ANSI C

Documents

Transcript of MPLAB C18: Librerias ANSI C