MPLAB C18: Librerias ANSI C by Dragoon Micromar

Rev: 1.0

MPLAB C18: LibrerĂas ANSI C

Omar Gurrola http://www.proprojects.wordpress.com 7/24/2012

MPLAB C18: Librerías ANSI C

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

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

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

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

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

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

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

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

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

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

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

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

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]

MPLAB C18: Librerías ANSI C 16.1.

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

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

17. Librería <reset.h> ..................................................................................................................... 44 18. Tabla ASCII ............................................................................................................................... 45 19. REFERENCIAS ............................................................................................................................ 46

Revisión: 1.0 [07/2012]

MPLAB C18: Librerías ANSI C

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

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.

Revisión: 1.0 [07/2012]

MPLAB C18: Librerías ANSI C

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

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]

MPLAB C18: Librerías ANSI C

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

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:

Macro

void assert(int test);

Directiva

#define NDEBUG

Descripción: 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. 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. 2.

Para activar el simulador: Debuger >> Select Tool >> MPLAB SIM 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]

MPLAB C18: Librerías ANSI C

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

#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: * Date: * Site: * * File: * Program: * Description: */

Omar Gurrola 05/29/12 http://www.proprojects.wordpress.com main.c MPLAB C18: Librerías ANSI C 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]

MPLAB C18: Librerías ANSI C

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

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. La librería consta de: Tipo: Función Función Función Función Función Función Función Función Función

Nombre: int tolower(int); int toupper(int); int isalnum(int); int isalpha(int);; int iscntrl(int); int isdigit(int); int isgraph(int); int islower(int); int isprint(int);

Descripción: Convierte un carácter a minúscula Convierte un carácter a mayúscula Si el carácter es alfanumérico regresa verdadero Si el carácter es una letra regresa verdadero Si el carácter es un control regresa verdadero Si el carácter es un digito regresa verdadero Si el carácter es imprimible regresa verdadero Si el carácter está en minúscula regresa verdadero Si el carácter es imprimible regresa verdadero

Función

int ispunct(int);

Si el carácter es de puntuación regresa verdadero

Función Función Función

int isspace(int); int isupper(int); int isxdigit(int);

Si el carácter es un espacio regresa verdadero Si el carácter esta en mayúscula regresa verdadero Si el carácter es hexadecimal regresa verdadero

Rango: (a-z) => (A-Z) (A-Z) => (a-z) (a-z), (A-Z), (0-9) (a-z), (A-Z) (0x00-0x1F), 0x7F (0-9) (0x21-0x7E) (a-z) (0x20-0x7E) (0x21-0x29), (0x2A-0x2F), (0x3A-0x40), (0x5B-0x60), (0x7B-x7F), 0x80 0x09, (0x0A-0x0D), 0x20 (A-Z) (0-9), (A-F), (a-f)

Cantidad: 26 26 62 52 33 10 94 26 95 32 6 26 22

2.1. Ejemplo con <ctype.h> main.c /* * Autor: * Date: * Site: * * File: * Program: * Description: */

Omar Gurrola 05/29/12 http://www.proprojects.wordpress.com main.c MPLAB C18: Librerías ANSI C 2.1. Ejemplo con <ctype.h>

#include <ctype.h> void main(void) { char c[8]; unsigned char unsigned char unsigned char unsigned char unsigned char unsigned char unsigned char unsigned char unsigned char unsigned char unsigned char unsigned char

ascii; AlphaNumerics = 0; Letters = 0; Controls = 0; Digits = 0; Graphs = 0; Lowers = 0; Prints = 0; Punctuations = 0; Spaces = 0; Uppers = 0; Hexadecimals = 0;

// Convierte a minuscula c[0] = tolower('A'); c[1] = tolower('B'); c[2] = tolower('c'); c[3] = tolower('&');

// // // //

a b Se queda igual Se queda igual

// Convierte a mayuscula

Revisión: 1.0 [07/2012]

MPLAB C18: Librer铆as ANSI C c[4] c[5] c[6] c[7]

= = = =

toupper('d'); toupper('e'); toupper('F'); toupper('^');

// // // //

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

D E Se queda igual 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]

MPLAB C18: Librerías ANSI C

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

3. Librería <errno.h> Esta librería la utilizan otras librerías para administrar errores. La librería consta de: Tipo: Macro Macro Variable

Nombre: EDOM ERANGE int errno

Descripción: Su valor representa un error de dominio que regresan algunas funciones matemáticas Su valor representa un error de rango que regresan algunas funciones matemáticas 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]

MPLAB C18: Librerías ANSI C

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

4. Librería <float.h> Esta librería define los límites máximos y mínimos de variables flotantes y dobles. La librería consta de: Tipo:

Nombre:

Macro

FLT_ROUNDS

Macro

FLT_RADIX

Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro Macro

FLT_MANT_DIG DBL_MANT_DIG LDBL_MANT_DIG FLT_DIG DBL_DIG LDBL_DIG FLT_MIN_EXP DBL_MIN_EXP LDBL_MIN_EXP FLT_MIN_10_EXP DBL_MIN_10_EXP LDBL_MIN_10_EXP FLT_MAX_EXP DBL_MAX_EXP LDBL_MAX_EXP FLT_MAX_10_EXP DBL_MAX_10_EXP LDBL_MAX_10_EXP FLT_MAX DBL_MAX LDBL_MAX FLT_EPSILON DBL_EPSILON LDBL_EPSILON FLT_MIN DBL_MIN LDBL_MIN

float.h /* * * * * * * * */ #ifndef #define

Descripción: 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 Define la base con la que se representan los exponentes. (base 2 - binario, base 10 - decimal, base 16 - hexadecimal)

Valor en C18:

Define el número de dígitos

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

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

-126

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

-37

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

128

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

Valor máximo en punto decimal

1.17549435E-38

Digito menos significativo presentable

1.19209290E-07

Valor mínimo en punto decimal

6.80564693E+38

Revisión: 1.0 [07/2012]

MPLAB C18: Librer铆as ANSI C

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

/* 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 #define #define #define #define #define #define #define

DBL_MANT_DIG FLT_MANT_DIG DBL_MIN_EXP FLT_MIN_EXP DBL_MAX_EXP FLT_MAX_EXP DBL_MIN_10_EXP FLT_MIN_10_EXP DBL_MAX_10_EXP FLT_MAX_10_EXP DBL_MIN FLT_MIN DBL_MAX FLT_MAX DBL_EPSILON FLT_EPSILON

#define #define #define #define #define #define #define #define

LDBL_MANT_DIG FLT_MANT_DIG LDBL_MIN_EXP FLT_MIN_EXP LDBL_MAX_EXP FLT_MAX_EXP LDBL_MIN_10_EXP FLT_MIN_10_EXP LDBL_MAX_10_EXP FLT_MAX_10_EXP LDBL_MIN FLT_MIN LDBL_MAX FLT_MAX 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]

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

MPLAB C18: Librerías ANSI C 5. Librería <limits.h>

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

Nombre: CHAR_BIT SCHAR_MIN SCHAR_MAX UCHAR_MAX CHAR_MIN CHAR_MAX MB_LEN_MAX SHRT_MIN SHRT_MAX USHRT_MAX INT_MIN INT_MAX UINT_MAX LONG_MIN LONG_MAX ULONG_MAX

limits.h #ifndef __LIMITS_H #define __LIMITS_H #define CHAR_BIT #define MB_LEN_MAX

8 2

#define SCHAR_MIN #define SCHAR_MAX #define UCHAR_MAX /* changed '\x80' #if 0x80 < 0 #define CHAR_MIN #define CHAR_MAX #else #define CHAR_MIN #define CHAR_MAX #endif

Descripción: Numero de bits en un byte Valor mínimo para signed char Valor máximo para signed char Valor máximo para unsigned char Valor mínimo para char Valor máximo para char Numero máximo de bytes en un carácter multi-byte Valor mínimo para short Valor máximo para short Valor máximo para unsigned short Valor mínimo para int Valor máximo para int Valor máximo para unsigned int Valor mínimo para long Valor máximo para long Valor máximo para unsigned long

(-128) 127 255

Valor en C18: 8 -128 127 255 -128 127 2 -32768 32767 65535 -32768 32767 65535 0x80000000 0x7FFFFFFF 0xFFFFFFFF

/* number of bits in a char */ /* max. # bytes in multibyte char */ /* minimum signed char value */ /* maximum signed char value */ /* maximum unsigned char value */

to 0x80 on the next line */ /* signed chars ? */ SCHAR_MIN /* minimum char value */ SCHAR_MAX /* maximum char value */ /* unsigned chars */ 0 UCHAR_MAX

#define SHRT_MIN #define SHRT_MAX #define USHRT_MAX

(-32767-1) 32767 65535U

#define LONG_MIN #define LONG_MAX #define ULONG_MAX

0x80000000 0x7fffffff 0xffffffff

#define SLONG_MIN #define SLONG_MAX #define USLONG_MAX

0x800000 0x7fffff 0xffffff

/* minimum signed short value */ /* maximum signed short value */ /* maximum unsigned short value */

/* minimum signed short long value */ /* maximum signed short long value */ /* 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]

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

MPLAB C18: Librerías ANSI C 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. La librería consta de: Tipo: Macro

Nombre: HUGE_VAL

Función

double acos(double x);

Función

double asin(double x);

Función

double atan(double x);

Función

double atan2(double x, double y);

Función Función Función Función Función

double cos(double x); double cosh(double x); double sin(double x); double sinh(double x, double y); double tan(double x);

Función

double tanh(double x);

Función

double exp(double x);

Función

double frexp(double x, int *exponent);

Función Función Función Función Función Función Función Función Función Función

double ldexp(double x, int exponent); double log(double x); double log10(double x); double modf(double x, double* integer); double pow(double x, double y); double sqrt(double x); double ceil(double x); double fabs(double x); double floor(double x); double fmod(double x, double y);

Revisión: 1.0 [07/2012]

Categoría: 6.3e38

Funciones Trigonométricas

Exponenciales, Logarítmicos y Potencias

Otras

Descripción: Lo regresan las funciones siguientes cuando el resultado es demasiado grande para ser mostrado. Regresa el arco coseno de x (-1 a +1) en radianes (0 a Pi) Regresa el arco seno de x (-1 a +1) en radianes (-Pi/2 a +Pi/2) Regresa el arco tangente de x en radianes (-Pi/2 a +Pi/2) Regresa el arco tangente de x/y (x & y ! = 0) en radianes (-Pi/2 a +Pi/2) Regresa el coseno de x (-1 a +1) en radianes Regresa el coseno hiperbólico de x en radianes Regresa el seno de x en radianes (-1 a +1) Regresa el seno hiperbólico de x en radianes Regresa el tangente de x en radianes Regresa el tangente hiperbólico de x en radianes (-1 a +1) Regresa el valor de e a la x potencia 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 Regresa x multiplicado por 2^exponent Regresa el logaritmo natural de x Regresa el logaritmo base 10 de x Parte el valor x en entero y decimal Regresa x elevado a la potencia y Regresa la raíz cuadrada de x Regresa el valor entero igual o mayor a x Regresa el valor absoluto de x Regresa el valor entero igual o menor a x Regresa el resto de dividir x / y

MPLAB C18: Librerías ANSI C

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

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; z = asin(x);

// x (-1 a +1), z (-Pi/2 a +Pi/2) radianes // z = 0

x = 0; z = atan(x);

// z (-Pi/2 a +Pi/2) radianes // z = 0

x = 1; y = 2; z = atan2(x,y);

// x / y, z (-Pi/2 a +Pi/2) radianes // z = 0.4636

x = 0; z = cos(x);

// z (-1 a +1) // z = 1

x = 0; z = cosh(x);

// // z = 1

x = 0; z = sin(x);

// z (-1 a +1) // z = 0

x = 0; z = sinh(x);

// // z = 0

x = 0; z = tan(x);

// // z = 0

x = 0; z = tanh(x);

// z (-1 a +1) // 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 = ldexp(x,y);

// z = x * 2^y // z = 256

x = 2.718282; z = log(x);

// z = log e (x) // z = 1

x = 1000; z = log10(x);

// // z = 3

x = 3.1416; z = modf(x,&y);

// z = Decimal, y = Entero // z = 0.14159, y = 3.0

x = 5; y = 2; z = pow(x,y);

// z = x ^ y // z = 25

x = 16; z = sqrt(x);

// z = (x)^0.5 // z = 4

// Otras x = 6.01; z = ceil(x);

// ^ // z = 7

x = -55; z = fabs(x);

// z = |x| // z = 55

x = 5.99;

// V

Revisión: 1.0 [07/2012]

MPLAB C18: Librer铆as ANSI C z = floor(x);

// z = 5

x = 5; y = 2; z = fmod(x,y);

// // z = 1

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

}

Revisi贸n: 1.0 [07/2012]

MPLAB C18: Librerías ANSI C

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

8. Librería <setjmp.h> Esta librería se utiliza para controlar llamadas y retornos a funciones en bajo nivel. La librería consta de: Tipo: Macro

Nombre: int setjmp(jmp_buf entorno)

Variables

void longjmp(jmp_buf entorno, int valor);

Función

typedef jmp_buf

Descripción: 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() 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 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]

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

MPLAB C18: Librerías ANSI C 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); }

La librería consta de: Tipo:

Nombre:

Macro

void va_start(va_list ap, last_arg);

Macro Macro

tipo va_arg(va_list ap, tipo); void va_end(va_list ap);

Variable

typedef <tipo> va_list

Descripción: Inicializa ap con las macros va_arg y va_end, es la primera que se debe llamar. Regresa el siguiente argumento. Permite que la función que utilizo va_start regrese 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);

Revisión: 1.0 [07/2012]

// mostramos el mensaje y la suma

MPLAB C18: Librer铆as ANSI C va_end(ap);

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

// regresamos con va_end()

}

Revisi贸n: 1.0 [07/2012]

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

MPLAB C18: Librerías ANSI C 11. Librería <stddef.h>

Esta librería contiene algunas definiciones estándares, algunas pueden estar definidas en otras cabeceras. La librería consta de: Tipo: Macro Macro Variable Variable Variable

Nombre: NULL offsetof(tipo, miembro); typedef ptrdiff_t typedef size_t typedef wchar_t

Descripción: Valor de una constante nula Regresa la posición o nivel donde se aloja el miembro en tipo Variable para almacenar la diferencia entre dos punteros Variable para almacenar el resultado de size_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]

MPLAB C18: Librer铆as ANSI C

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

main.c #include<stddef.h> void main(void) { struct persona{ // char nombre[50]; // char apellido[50]; // int edad; // int altura; // }; unsigned int offset_nombre; unsigned int offset_apellido; unsigned int offset_edad; unsigned int offset_altura;

Estructura Posicion 0 Posicion 50 Posicion 100 Posicion 102

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]

MPLAB C18: Librerías ANSI C

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

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;

La librería consta de: Tipo: Macro

Nombre: MEM_MODEL

Macro

EOF

Macro Macro Macro Macro Macro

FILE _H_USER _H_USART FILE *stderr FILE *stdout

Función

int printf (const rom char *fmt, …);

Función

int fprintf (FILE *f, const rom char *fmt, …);

Función

int sprintf(char *buf, const rom char *ftm, …);

Función

int puts (auto const rom char *s);

Función

int fputs (const rom char *s, auto FILE *f);

Función

int putc (char c, FILE *f);

Revisión: 1.0 [07/2012]

Descripción: Define el modelo de memoria que se está utilizando, por default es far Define el final de archivo, lo regresan algunas funciones cuando hubo algún error Es utilizado para definir el stream de salida Stream de salida definida por el usuario Stream de salida definida para el USART Stream salida estándar de error Stream de salida estándar 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. 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. 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. 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. 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. Envía un carácter al stream especificado (_H_USART o _H_USER). Regresa: en error EOF, en otro el carácter enviado.

MPLAB C18: Librerías ANSI C

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

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 int int int int int int int int

putc (auto char c, auto FILE *f); vsprintf (auto char *buf, auto const MEM_MODEL rom char *fmt, auto va_list ap); vprintf (auto const MEM_MODEL rom char *fmt, auto va_list ap); sprintf (auto char *buf, auto const MEM_MODEL rom char *fmt, ...); printf (auto const MEM_MODEL rom char *fmt, ...); fprintf (auto FILE *f, auto const MEM_MODEL rom char *fmt, ...); vfprintf (auto FILE *f, auto const MEM_MODEL rom char *fmt, auto va_list ap); puts (auto const MEM_MODEL rom char *s); 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("05. printf("06. printf("07. printf("08. printf("09. printf("10. printf("11. printf("12. printf("13. printf("14.

printf(), fprintf(), sprintf(), vfprintf(), vprintf() y vsprintf() %s",Cadena_RAM); // Cadena en RAM %S",Cadena_NROM); // Cadena en Near ROM %HS",Cadena_FROM); // Cadena en Far ROM %% \\ \' \" \? \t \n\0"); // \t = TAB, \r = Retorno, \n = Nueva línea, \0 = Nulo %c, %c, %c\n",0,255,'A'); // Carácter, unsigned char %d, %i\n",(int)-32767,(int)32767); // Decimal con signo, int %u, %u\n",(unsigned int)0,(unsigned int)65535);// Decimal sin signo, unsigned int %o, %o\n",(unsigned int)0,(unsigned int)65535);// Octal, unsigned int %b, %B\n",(unsigned int)0,(unsigned int)65535);// Binario, unsigned int %x, %X\n",(unsigned int)0,(unsigned int)65535);// Hex, x = min, X = may, unsigned int

Revisión: 1.0 [07/2012]

MPLAB C18: Librerías ANSI C

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

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]

MPLAB C18: Librerías ANSI C

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

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]

MPLAB C18: Librerías ANSI C

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

// 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]

MPLAB C18: Librer铆as ANSI C 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. 91. 92. 93. 94. 95.

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

0, 377 0, 11111111 0, FF 0, FFFF -32767, 32767 0, 65535 0, 177777 0, 1111111111111111 0, FFFF 0, FFFF -8388607, 8388607 0, 16777215 0, 77777777 0, 111111111111111111111111 0, FFFFFF 0, FFFFFF -2147483647, 2147483647 0, 4294967295 0, 37777777777 0, 11111111111111111111111111111111 0, FFFFFFFF Cadena en RAM Cadena en NEAR ROM Cadena en FAR ROM a, b -32767, 32767 0, 65535 0, 177777 0, 1111111111111111 0, FFFF 0, FFFF 0, FFFFFF Cadena en RAM Cadena en NEAR ROM Cadena en FAR ROM a, b -32767, 32767 0, 65535 0, 177777 0, 1111111111111111 0, FFFF 0, FFFF 0, FFFFFF Cadena en R Cadena en N Cadena en F -000000000032767, 0000000000032767 0000000000000000, 0000000000065535 0000000000000000, 0000000000177777 0000000000000000, 1111111111111111 0000000000000000, 000000000000FFFF 0000000000000000, 000000000000FFFF 0000000000000000, 0000000000FFFFFF Cadena en R Cadena en N Cadena en F -000000000032767, 0000000000032767 0000000000000000, 0000000000065535 0000000000000000, 0000000000177777 0000000000000000, 1111111111111111 0000000000000000, 000000000000FFFF 0000000000000000, 000000000000FFFF 0000000000000000, 0000000000FFFFFF 00, 0177777 0b0, 0B1111111111111111 0x0, 0XFFFF 0x0, 0XFFFF 0x0, 0XFFFFFF -32767, +32767 -32767, 32767 -000000000032767, 0000000000032767 0000000000000000, 0000000000065535 0000000000000000, 0000000000177777 0000000000000000, 1111111111111111 0000000000000000, 000000000000FFFF 0000000000000000, 000000000000FFFF 0000000000000000, 0000000000FFFFFF

Revisi贸n: 1.0 [07/2012]

MPLAB C18: Librerías ANSI C

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

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]

MPLAB C18: Librerías ANSI C

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

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). La librería consta de: Tipo: Macro

Nombre: RAND_MAX

Función

char atob (const char *s);

Función

double atof (const char *s);

Función

int atoi (const char *s);

Función

long atol (const char *s);

Función

char *btoa (signed char value, char *s);

Función

char *itoa (int value, char *s);

Función

char *ltoa (long value, char *s);

Función

char *ultoa (unsigned long value, char *s);

Función

unsigned long atoul (const char *s);

Función

int rand (void);

Función

void srand (unsigned int seed);

Descripción: Macro que define el valor máximo que puede regresar la función rand() Convierte una cadena a 8 bits con signo, puede llevar al inicio + o -, radix 10 [-128, 127] Convierte una cadena a 32 bits flotante, radix 10 [1.17549435E-38, 6.80564693E+38] Convierte una cadena a 16 bits con signo, puede llevar al inicio + o -, radix 10 [-32768, 32767] Convierte una cadena a 32 bits con signo, puede llevar al inicio + o -, radix 10 [-2147483648, 2147483647] Convierte un valor de 8 bits con signo a cadena, [-128, 127] Convierte un valor de 16 bits con signo a cadena, [-32768, 32767] Convierte un valor de 32 bits con signo a cadena, [-2147483648, 2147483647] Convierte un valor de 32 bits sin signo a cadena, [0, 4294967295] Convierte una cadena a 32 bits sin signo, puede llevar al inicio +, radix 10 [0, 4294967295] Regresa un valor aleatorio tipo entero, [0, RAND_MAX] 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]

MPLAB C18: Librer铆as ANSI C

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

* {\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]

MPLAB C18: Librer铆as ANSI C

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

/** @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]

MPLAB C18: Librer铆as ANSI C

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

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)); // // // f1 f2 f3

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 = atof(f32_min); // f1 = 1.175494e-030 = atof(f32_max); // f2 = 6.805647e+037 = 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. 02. 03. 04. 05. 06. 07. 08. 09. 10.

-128,127,127 -32768,32767,32767 -2147483648,2147483647,2147483647 0,4294967295,4294967295 -128,127 -32768,32767 -2147483648,2147483647 0,4294967295 4764,655,20502,7009 31200,2371,5754,2229

Revisi贸n: 1.0 [07/2012]

MPLAB C18: Librerías ANSI C

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

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). La librería consta de: Tipo: Macro

Nombre: MEM_MODEL

Función

void *memchr (const void *s, unsigned char c, size_t n);

Función

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

Función

signed char memcmp (const void *s1, const void *s2, size_t n);

Función Función Función Función Función Función Función Función Función Función Función

signed char memcmppgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n); signed char memcmppgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n); signed char memcmpram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n); void *memcpy (void *s1, const void *s2, size_t n); MEM_MODEL rom void *memcpypgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n); void *memcpypgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n); MEM_MODEL rom void *memcpyram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n); void *memmove (void *s1, const void *s2, size_t n); MEM_MODEL rom void *memmovepgm (MEM_MODEL rom void *s1, const MEM_MODEL rom void *s2, sizerom_t n); void *memmovepgm2ram (void *s1, const MEM_MODEL rom void *s2, sizeram_t n); MEM_MODEL rom void *memmoveram2pgm (MEM_MODEL rom void *s1, const void *s2, sizeram_t n);

Función

void *memset (void *s, unsigned char c, size_t n);

Función

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

Función

char *strcat (char *s1, const char *s2);

Función

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

Función

char *strcatpgm2ram (char *s1, const MEM_MODEL rom char *s2);

Función

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

Función

char *strchr (const char *s, unsigned char c);

Función

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

Función

signed char strcmp (const char *s1, const char *s2);

Función Función Función Función

signed char strcmppgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); signed char strcmppgm2ram (const char *s1, const MEM_MODEL rom char *s2); signed char strcmpram2pgm (const MEM_MODEL rom char *s1, const char *s2); char *strcpy (char *s1, const char *s2);

Revisión: 1.0 [07/2012]

Descripción: Define el modelo de memoria, puede ser far o near (por default es far) 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. 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. 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 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 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 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 Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (NSP), RAMaRAM Regresa: La dirección de s1 Copia el contenido de s2 a s1 hasta n elementos, (NSP), ROMaROM (Externa) Regresa: La dirección de s1 Copia el contenido de s2 a s1 hasta n elementos, (NSP), ROMaRAM Regresa: La dirección de s1 Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (NSP), RAMaROM (Externa) Regresa: La dirección de s1 Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (SSP), RAMaRAM Regresa: La dirección de s1 Copia el contenido de s2 a s1 hasta n elementos, (SSP), ROMaROM (Externa) Regresa: La dirección de s1 Copia el contenido de s2 a s1 hasta n elementos, (SSP), ROMaRAM Regresa: La dirección de s1 Copia el contenido de s2 a s1 hasta n elementos o ‘\0’, (SSP), RAMaROM (Externa) Regresa: La dirección de s1 Copia el valor o carácter al arreglo RAM s hasta n veces. Regresa: La dirección de s Copia el valor o carácter al arreglo ROM (Externa) s hasta n veces. Regresa: La dirección de s Añade una copia la cadena s2 al final de s1, (NSP), RAMaRAM. Regresa: La dirección de s1 Añade una copia la cadena s2 al final de s1, (NSP), ROMaROM (Externa) Regresa: La dirección de s1 Añade una copia la cadena s2 al final de s1, (NSP), ROMaRAM. Regresa: La dirección de s1 Añade una copia la cadena s2 al final de s1, (NSP), RAMaROM (Externa) Regresa: La dirección de s1 Busca el carácter c en la cadena RAM s Regresa: Puntero al carácter, en otro caso puntero nulo. Busca el carácter c en la cadena ROM s Regresa: Puntero al carácter, en otro caso puntero nulo. 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 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 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 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 Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP),

MPLAB C18: Librerías ANSI C

Función

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

Función

char *strcpypgm2ram (char *s1, const MEM_MODEL rom char *s2);

Función

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

Función

size_t strcspn (const char *s1, const char *s2);

Función

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

Función

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

Función

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

Función

size_t strlen (const char *s);

Función

sizerom_t strlenpgm (const MEM_MODEL rom char *s);

Función

char *strlwr (char *s);

Función

MEM_MODEL rom char *strlwrpgm (MEM_MODEL rom char *s);

Función

char *strupr (char *s);

Función

MEM_MODEL rom char *struprpgm (MEM_MODEL rom char *s);

Función

char *strncat (char *s1, const char *s2, size_t n);

Función Función Función Función Función Función Función Función Función Función Función Función Función Función Función

MEM_MODEL rom char *strncatpgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n); char *strncatpgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n); MEM_MODEL rom char *strncatram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n); signed char strncmp (const char *s1, const char *s2, size_t n); signed char strncmppgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n); signed char strncmppgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n); signed char strncmpram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n); char *strncpy (char *s1, const char *s2, size_t n); MEM_MODEL rom char *strncpypgm (MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2, sizerom_t n); char *strncpypgm2ram (char *s1, const MEM_MODEL rom char *s2, sizeram_t n); MEM_MODEL rom char *strncpyram2pgm (MEM_MODEL rom char *s1, const char *s2, sizeram_t n); char *strpbrk (const char *s1, const char *s2); MEM_MODEL rom char *strpbrkpgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); MEM_MODEL rom char *strpbrkpgmram (const MEM_MODEL rom char *s1, const char *s2); char *strpbrkrampgm (const char *s1, const MEM_MODEL rom char *s2);

Función

char *strrchr (const char *s, unsigned char c);

Función

size_t strspn (const char *s1, const char *s2);

Revisión: 1.0 [07/2012]

Omar Gurrola http://www.proprojects.wordpress.com RAMaRAM, Regresa: La dirección de s1 Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), ROMaROM, Regresa: La dirección de s1 Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), ROMaRAM, Regresa: La dirección de s1 Copia el contenido de la cadena s2 a s1 incluyendo el carácter nulo, (NSP), RAMaROM, Regresa: La dirección de s1 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) 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) 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) 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) Calcula la longitud de la cadena s en RAM Regresa: La longitud en size_t Calcula la longitud de la cadena s en ROM, Regresa: La longitud en sizerom_t Convierte todos los caracteres mayúsculas a minúsculas de una cadena s, RAM Regresa: La dirección de s Convierte todos los caracteres mayúsculas a minúsculas de una cadena s ROM Regresa: La dirección de s Convierte todos los caracteres minúsculas a mayúsculas de una cadena s, RAM Regresa: La dirección de s Convierte todos los caracteres minúsculas a mayúsculas de una cadena s ROM Regresa: La dirección de s Añade la cantidad especifica de caracteres de la Cadena s2 al final de s1, (NSP), RAMaRAM. Regresa: La dirección de s1 Añade la cantidad especifica de caracteres de la Cadena s2 al final de s1, (NSP), RAMaROM. Regresa: La dirección de s1 Añade la cantidad especifica de caracteres de la Cadena s2 al final de s1, (NSP), ROMaRAM. Regresa: La dirección de s1 Añade la cantidad especifica de caracteres de la Cadena s2 al final de s1, (NSP), ROMaROM. Regresa: La dirección de s1 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 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 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 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 Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), RAMaRAM, Regresa: La dirección de s1 Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), ROMaROM, Regresa: La dirección de s1 Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), ROMaRAM, Regresa: La dirección de s1 Copia el contenido de la cadena s2 a s1 hasta n caracteres, (NSP), RAMaROM, Regresa: La dirección de s1 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. 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. 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. 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. Busca la última ocurrencia del carácter c en la cadena s, RAMyRAM Regresa: Puntero al carácter, en otro caso nulo. Calcula el número de caracteres en s2 que coinciden en s1, RAMaRAM Regresa: El número de caracteres similares desde el inicio.

MPLAB C18: Librerías ANSI C Función Función Función Función Función Función Función

sizerom_t strspnpgm (const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); sizerom_t strspnpgmram (const MEM_MODEL rom char *s1, const char *s2); sizeram_t strspnrampgm (const char *s1, const MEM_MODEL rom char *s2); char *strstr (const char *s1, const char *s2); MEM_MODEL rom char *strstrpgm (auto const MEM_MODEL rom char *s1, const MEM_MODEL rom char *s2); MEM_MODEL rom char *strstrpgmram (const MEM_MODEL rom char *s1, const char *s2); char *strstrrampgm (const char *s1, const MEM_MODEL rom char *s2);

Función

char *strtok (char *s1, const char *s2);

Función

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

Función

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

Función

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

Omar Gurrola http://www.proprojects.wordpress.com Calcula el número de caracteres en s2 que coinciden en s1, ROMaROM Regresa: El número de caracteres similares desde el inicio. Calcula el número de caracteres en s2 que coinciden en s1, ROMaRAM Regresa: El número de caracteres similares desde el inicio. Calcula el número de caracteres en s2 que coinciden en s1, RAMaROM Regresa: El número de caracteres similares desde el inicio. Localiza la subcadena s2 dentro de la cadena s1, RAMaRAM Regresa: Puntero a la cadena, en otro caso nulo Localiza la subcadena s2 dentro de la cadena s1, ROMaROM Regresa: Puntero a la cadena, en otro caso nulo Localiza la subcadena s2 dentro de la cadena s1, ROMaRAM Regresa: Puntero a la cadena, en otro caso nulo Localiza la subcadena s2 dentro de la cadena s1, RAMaROM Regresa: Puntero a la cadena, en otro caso nulo 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 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 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 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]

MPLAB C18: Librer铆as ANSI C

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

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]

MPLAB C18: Librerías ANSI C

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

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]

MPLAB C18: Librerías ANSI C

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

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, // Copia el contenido de s2 a s1 // Regresa: La dirección de s1 printf("12. Direccion de destino: printf("13. Origen: %HS, Destino: // // // //

const MEM_MODEL rom void *s2, sizeram_t n); hasta n elementos, (NSP), ROMaRAM 0x%P\n",memcpypgm2ram(CadDest_RAM,Cadena_ROM,20)); // Copiamos ROMaRAM %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]

MPLAB C18: Librerías ANSI C

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

// 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]

MPLAB C18: Librerías ANSI C

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

// 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]

MPLAB C18: Librerías ANSI C

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

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]

MPLAB C18: Librerías ANSI C

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

// 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]

MPLAB C18: Librerías ANSI C

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

// 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]

MPLAB C18: Librer铆as ANSI C 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60.

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

La cadena hasta 3 es: Hola mundo!!123a RAMvsRAM 4 carac: Hola mundo!! = Hola software!! ROMvsROM 4 carac: Hola mundo!! = Hola c18!! RAMvsROM 6 carac: Hola mundo!! > Hola c18!! ROMvsRAM 6 carac: Hola c18!! < Hola mundo!! La cadena: Hola mundo!! en RAM, hasta 4 caract. es: Hola La cadena: Hola mundo!! en ROM, hasta 4 caract. es: Hola Cadena: Hola mundo!!, Buscar: aeiou, Inicio: 0x0301, Encontrado: 0x0302 Cadena: Hola mundo!!, Buscar: aeiou, Inicio: 0x4BF4, Encontrado: 0x4BF5 Cadena: Hola mundo!!, Buscar: aeiou, Inicio: 0x4BF4, Encontrado: 0x4BF5 Cadena: Hola mundo!!, Buscar: aeiou, Inicio: 0x0301, Encontrado: 0x0302 La cadena: Hola mundo!!, Inicio: 0x0301, Ultima ocurrencia en: 0x030c La cadena: Hola mundo!!, de: Holo mundo!!, Tiene: 3 La cadena: Hola mundo!!, de: Holo mundo!!, Tiene: 3 La cadena: Hola mundo!!, de: Holo mundo!!, Tiene: 3 La cadena: Hola mundo!!, de: Holo mundo!!, Tiene: 3 Cadena: Hola mundo!!, Subcadena: mundo, Inicio: 0x0301, Posicion: 0x0306 Cadena: Hola mundo!!, Subcadena: mundo, Inicio: 0x4BF4, Posicion: 0x4BF9 Cadena: Hola mundo!!, Subcadena: mundo, Inicio: 0x4BF4, Posicion: 0x4BF9 Cadena: Hola mundo!!, Subcadena: mundo, Inicio: 0x0301, Posicion: 0x0306 Subcadenas: 0x031E=Test1 0x0324=Test2 0x032A=Test3 0x0330=Test4 0x0336=Test5 Subcadenas: 0x031E=Test1 0x0324=Test2 0x032A=Test3 0x0330=Test4 0x0336=Test5

Revisi贸n: 1.0 [07/2012]

MPLAB C18: Librerías ANSI C

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

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 La librería consta de: Tipo: Macro

Nombre: #define Delay1TCY() Nop()

Función

void Delay10TCYx(unsigned char unit);

Función

void Delay100TCYx(unsigned char unit);

Función

void Delay1KTCYx(unsinged char unit);

Función

void Delay10KTCYx(unsigned char unit);

Descripción: Retardo de 1xTCY Retardo en múltiples de 10xTCY unit = 0, 2,560xTCY Retardo en múltiples de 100xTCY unit = 0, 25,600xTCY Retardo en múltiples de 1KxTCY unit = 0, 256,000xTCY 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]

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

MPLAB C18: Librer铆as ANSI C /* 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 * The 18Cxxx version of this function * The 17Cxxx version supports [2,255] */ void Delay10TCYx(PARAM_SCLASS unsigned

of 2560 cycles. supports the full range [0,255] and 0. 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(); // Delay10TCYx(120); // Delay100TCYx(120); // Delay1KTCYx(120); // Delay10KTCYx(120); // }

Retardo Retardo Retardo Retardo Retardo

Revisi贸n: 1.0 [07/2012]

de de de de de

1xTCY = 83.33ns 120x10xTCY = 120us x100xTCY = 1ms x1KxTCY = 10ms x10KxTCY = 100ms

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

MPLAB C18: Librerías ANSI C 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. La librería consta de: Tipo: Macro Macro

Nombre: WDT_ENABLED STVR_ENABLED

Funcion

char isBOR(void);

Funcion

char isLVD(void);

Funcion

char isMCLR(void);

Funcion

char isPOR(void);

Funcion

char isWDTTO(void);

Funcion

char isWDTWU(void);

Funcion

char isWU(void);

Funcion

void StatusReset(void);

Descripción: Habilita el uso de las funciones isWDTTO(); y isWDTWU(); Permite que se genere el evento reset cuando hay un desbordamiento. Determina si la causa del reset fue Brown-Out Regresa: 1 si fue la causa, en otro caso 0 Determina si la causa del reset fue Low-Voltage detect Regresa: 1 si fue la causa, en otro caso 0 Determina si la causa del reset fue el pin /MCLR Regresa: 1 si fue la causa, en otro caso 0 Determina si la causa del reset fue Power-on Reset Regresa: 1 si fue la causa, en otro caso 0 Determina si la causa del reset fue el timer del Watchdog. Regresa: 1 si fue la causa, en otro caso 0 Determina si la causa del wake-up fue el Watchdog timer Regresa: 1 si fue la causa, en otro caso 0 Determina si la causa del wake-up fue del /MCLR o interrupción Regresa: 1 si fue la causa, en otro caso 0 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 void char char

isMCLR(void); StatusReset(void); isPOR(void); isWU(void);

/* /* /* /*

MCLR reset? Reset the POR and BOR bits POR reset? 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); #endif

/*LVD-- Low voltage detect?

#endif /* __RESET_H */

Revisión: 1.0 [07/2012]

MPLAB C18: Librer铆as ANSI C

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

18. Tabla ASCII

Revisi贸n: 1.0 [07/2012]

MPLAB C18: Librerías ANSI C

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

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

Revisión: 1.0 [07/2012]

http://www.proprojects.wordpress.com