MikroC PRO para Bibliotecas PIC

mikroC PRO para bibliotecas PIC
mikroC PRO para PIC proporciona un conjunto de bibliotecas que simplifican la

inicialización y el uso de MCU compatibles con PIC y sus módulos:
Utilice el administrador de bibliotecas para incluir mikroC PRO para bibliotecas PIC
en su proyecto.
Bibliotecas de hardware
 Biblioteca ADC
 Biblioteca CAN
 Biblioteca CANSPI
 Biblioteca Compact Flash
 Biblioteca EEPROM
 Epson S1D13700 Graphic Lcd Library
 Biblioteca Ethernet PIC18FxxJ60
 Biblioteca de memoria flash
 Biblioteca Lcd Gráfica
 Biblioteca I²C
 Biblioteca de teclado
 Biblioteca lcd
 Biblioteca de códigos de Manchester
 Biblioteca del administrador de memoria
 Biblioteca de tarjetas multimedia
 Biblioteca OneWire
 Pin Periférico Select
 Biblioteca de Puerto Expander
 Biblioteca PS / 2
 Biblioteca de PWM
 Biblioteca RS-485
 Software I²C Library
 Software SPI Library
 Software UART Library
 Biblioteca de sonidos
 Biblioteca SPI
 Biblioteca extraíble SPI
 Biblioteca Ethernet SPI
 Biblioteca SPI Ethernet ENC24J600
 SPI Graphic Lcd Library
 Biblioteca SPI Lcd
 Biblioteca SPI Lcd8
 SPI T6963C Graphic Lcd Library
 T6963C Graphic Lcd Library
 TFT Display Library
 Biblioteca TFT de 16 bits
 Biblioteca de panel táctil
 Touch Panel TFT Library
 Biblioteca UART
 Biblioteca extraíble UART
 Biblioteca USB
Bibliotecas ANSI C estándar
 Biblioteca ANSI C Ctype
 Biblioteca de matemáticas ANSI C
 Biblioteca ANSI C Stdlib
 Biblioteca de cadenas ANSI C
Bibliotecas misceláneas
 Biblioteca de botones
 Biblioteca de conversiones
 Biblioteca de PrintOut
 Biblioteca de Setjmp
 Biblioteca Sprint
 Biblioteca de tiempo
 Biblioteca de trigonometría
Rutinas incorporadas
El compilador mikroC PRO for PIC proporciona un conjunto de funciones útiles de
utilidad incorporadas.
El Lo, Hi, Higher, Highestrutinas se implementan como macros. Si desea usar estas
funciones, debe incluir el built_in.harchivo de encabezado (ubicado en
la includecarpeta del compilador) en su proyecto.
Las rutinas Delay_usy Delay_msse implementan como "en línea"; es decir, el código
se genera en lugar de una llamada, por lo que la llamada no cuenta para el límite
de llamadas anidadas .
El Vdelay_ms, Vdelay_advanced_ms, Delay_Cyc, Get_Fosc_kHzy Get_Fosc_Per_Cycso
n reales rutinas C. Sus fuentes se pueden encontrar en el Delays.carchivo ubicado
en la usescarpeta del compilador.
 Lo
 Hola
 Mayor
 Más alto
 LoWord
 HiWord
 Retraso_us
 Delay_ms
 Vdelay_ms
 Vdelay_Advanced_ms
 Delay_Cyc
 Clock_kHz
 Reloj_MHz
 Get_Fosc_kHz
 Intercambiar
Rutinas incorporadas
El compilador mikroC PRO for PIC proporciona un conjunto de funciones útiles de
utilidad incorporadas.
El Lo, Hi, Higher, Highestrutinas se implementan como macros. Si desea usar estas
funciones, debe incluir el built_in.harchivo de encabezado (ubicado en
la includecarpeta del compilador) en su proyecto.
Las rutinas Delay_usy Delay_msse implementan como "en línea"; es decir, el código
se genera en lugar de una llamada, por lo que la llamada no cuenta para el límite
de llamadas anidadas .
El Vdelay_ms, Vdelay_advanced_ms, Delay_Cyc, Get_Fosc_kHzy Get_Fosc_Per_Cycso
n reales rutinas C. Sus fuentes se pueden encontrar en el Delays.carchivo ubicado
en la usescarpeta del compilador.
 Lo
 Hola
 Mayor
 Más alto
 LoWord
 HiWord
 Retraso_us
 Delay_ms
 Vdelay_ms
 Vdelay_Advanced_ms
 Delay_Cyc
 Clock_kHz
 Reloj_MHz
 Get_Fosc_kHz
 Intercambiar
Lo
Prototipo #define Lo (param) ((char *) & param) [0]
Devoluciones Los 8 bits más bajos (byte) de param, bits 7..0.
Descripción La función devuelve el byte más bajo de param. La función

no interpreta patrones de bits de param, simplemente
devuelve 8 bits como se encuentran en el registro.
Esta es una rutina "en línea"; El código se genera en el
lugar de la llamada, por lo que la llamada no cuenta para
el límite de llamadas anidadas .
Requiere Ninguna.
Ejemplo d = 0x12345678;
tmp = Lo (d); // es igual a 0x78
Lo (d) = 0xAA; // d es igual a 0x123456AA
Hola
Prototipo #define Hi (param) ((char *) & param) [1]
Devoluciones Devuelve junto al byte más bajo de param, bits 8..15.
Descripción La función regresa al lado del byte más bajo de param. La

función no interpreta patrones de bits de param,
simplemente devuelve 8 bits como se encuentran en el
registro.
Requiere Ninguna.
Ejemplo d = 0x12345678;
tmp = Hola (d); // es igual a 0x56
Hola (d) = 0xAA; // d es igual a 0x1234AA78
Mayor
Prototipo #define Higher (param) ((char *) & param) [2]
Devoluciones Regresa al lado del byte más alto de los parambits 16..23.
Descripción La función regresa al lado del byte más alto de param. La
función no interpreta patrones de bits de param,
simplemente devuelve 8 bits como se encuentran en el
registro.
Requiere Ninguna.
Ejemplo d = 0x12345678;
tmp = Superior (d); // es igual a 0x34
Superior (d) = 0xAA; // d es igual a 0x12AA5678
Más alto
Prototipo #define Highest (param) ((char *) & param) [3]
Devoluciones Devuelve el byte más alto de param, bits 24..31.
Descripción La función devuelve el byte más alto de param. La función

no interpreta patrones de bits de param, simplemente
Requiere Ninguna.
Ejemplo d = 0x12345678;
tmp = Más alto (d); // es igual a 0x12
Más alto (d) = 0xAA; // d es igual a 0xAA345678
LoWord
Prototipo unsigned int LoWord ( unsigned long number);
Descripción La función devuelve baja palabra de number. La función no

interpreta patrones de bits de number, simplemente
Parámetros  number: número de entrada
Devoluciones Baja palabra de number, bits 15..0.
Requiere Nada.
Ejemplo d = 0x12345678;
tmp = LoWord (d); // es igual a 0x5678
LoWord (d) = 0xAAAA; // d es igual a 0x1234AAAA
Notas Ninguna.
HiWord
Prototipo unsigned int HiWord ( unsigned long number);
Descripción La función devuelve alta palabra de number. La función no

interpreta patrones de bits de number, simplemente
Parámetros  number: número de entrada
Devoluciones Palabra alta de number, bits 31..16.
Requiere Nada.
Ejemplo d = 0x12345678;
tmp = HiWord (d); // es igual a 0x1234
HiWord (d) = 0xAAAA; // d es igual a 0xAAAA5678
Notas Ninguna.
Retraso_us
Prototipo void Delay_us ( const unsigned long time_in_us);
Devoluciones Nada.
Descripción Crea un retraso de software en la duración

de time_in_usmicrosegundos (una constante). El rango de
constantes aplicables depende de la frecuencia del
oscilador.
el límite de llamadas anidadas . Esta rutina genera bucles
anidados utilizando registros R13, R12, R11y R10. El número
de registros utilizados varía de 0 a 4, según lo
solicitado time_in_us.
Requiere Nada.
Ejemplo Delay_us (1000); / * Una pausa de milisegundos * /
Delay_ms
Prototipo void Delay_ms ( const unsigned long time_in_ms);
Devoluciones Nada.

de time_in_msmilisegundos (una constante). El rango de
constantes aplicables depende de la frecuencia del
oscilador.
el límite de llamadas anidadas . Esta rutina genera bucles
anidados utilizando registros R13, R12, R11y R10. El número
de registros utilizados varía de 0 a 4, según lo
solicitado time_in_ms.
Requiere Nada.
Ejemplo Delay_ms (1000); / * Una pausa de un segundo * /
Vdelay_ms
Prototipo void Vdelay_ms ( unsigned time_in_ms);
Devoluciones Nada.

de time_in_msmilisegundos (una variable). El retraso
generado no es tan preciso como el retraso creado
por Delay_ms .
Tenga en cuenta que Vdelay_mses una función de biblioteca
en lugar de una rutina incorporada; Se presenta en este
tema por conveniencia.
Requiere Nada.
Ejemplo pausa = 1000;

// ...
Vdelay_ms (pausa); // ~ una segunda pausa
VDelay_Advanced_ms
Prototipo void VDelay_Advanced_ms (tiempo sin firmar_in_ms,
Current_Fosc_kHz sin firmar );
Devoluciones Nada.

de time_in_msmilisegundos (una variable), para una
frecuencia de oscilador determinada. El retraso generado
no es tan preciso como el retraso creado por Delay_ms .
Tenga en cuenta que Vdelay_mses una función de biblioteca
tema por conveniencia.
Requiere Nada.
Ejemplo pausa = 1000;

fosc = 10000;
VDelay_Advanced_ms (pausa, fosc); // Genera

aproximadamente una pausa de un segundo, para una
frecuencia de oscilador de 10 MHz
Delay_Cyc
Prototipo void Delay_Cyc ( char Cycles_div_by_10);
Devoluciones Nada.
Descripción Crea un retraso basado en el reloj MCU. La demora dura 10

veces el parámetro de entrada en ciclos MCU.
Tenga en cuenta que Delay_Cyces una función de biblioteca
tema por conveniencia. Hay limitaciones para el valor de
Cycles_div_by_10. El valor Cycles_div_by_10 debe estar
entre 3 y 255.
Requiere Nada.
Ejemplo Delay_Cyc (10); / * Cien ciclos de MCU en pausa * /
Clock_kHz
Prototipo Clock_kHz sin firmar ( nulo );
Devoluciones Reloj del dispositivo en kHz, redondeado al entero más

cercano.
Descripción La función devuelve el reloj del dispositivo en kHz,

redondeado al entero más cercano.
Requiere Nada.
Ejemplo clk = Clock_kHz ();
Reloj_MHz
Prototipo corto sin firmar Clock_MHz ( void );
Devoluciones Reloj del dispositivo en MHz, redondeado al entero más

cercano.
Descripción La función devuelve el reloj del dispositivo en MHz,

Requiere Nada.
Ejemplo clk = Clock_MHz ();
Get_Fosc_kHz
Prototipo Get_Fosc_kHz largo sin firmar ( void );
Devoluciones Reloj del dispositivo en kHz, redondeado al entero más

cercano.
Descripción La función devuelve el reloj del dispositivo en kHz,

Tenga en cuenta que Get_Fosc_kHzes una función de
biblioteca en lugar de una rutina incorporada; Se presenta
en este tema por conveniencia.
Requiere Nada.
Ejemplo clk = Get_Fosc_kHz ();
Intercambiar
Prototipo permuta de char ( entrada de char );
Devoluciones Intercambiar nibbles del byte de entrada.
Descripción Función swaps nibbles del inputparámetro.

Requiere Nada.
Ejemplo Char de entrada, swapped_input;
entrada = 0xAF;
swapped_input = swap (entrada); // la rutina
devolverá 0xFA, es decir, intercambiar nibbles del
parámetro de entrada
Biblioteca ADC
El módulo ADC (Convertidor analógico a digital) está disponible con varios módulos
PIC MCU. ADC es un circuito electrónico que convierte señales continuas en
números digitales discretos. ADC Library le proporciona un trabajo cómodo con el
módulo.
Rutinas de la biblioteca
 ADC_Init
 ADC_Get_Sample
 ADC_Leer
ADC_Init
Prototipo void ADC_Init ();
Devoluciones Nada.
Descripción Esta rutina inicializa el módulo ADC interno de PIC para

que funcione con el reloj RC. El reloj determina el período
de tiempo necesario para realizar la conversión de AD
(mínimo 12TAD).
Requiere  MCU con módulo ADC incorporado .
Ejemplo ADC_Init (); // Inicializar el módulo ADC con la

configuración predeterminada
ADC_Get_Sample
Prototipo unsigned ADC_Get_Sample ( canal corto sin
firmar );
Devoluciones Se leyó un valor sin signo de 10 o 12 bits del canal

especificado (depende de MCU).
Descripción La función adquiere valor analógico del canal especificado.

El parámetro channelrepresenta el canal desde el cual se
va a adquirir el valor analógico. Consulte la hoja de datos
correspondiente para la asignación de canal a pin.
Nota: esta función no funciona con la fuente de

referencia de tensión externa, solo con la referencia de
tensión interna.
Requiere  La MCU con módulo ADC incorporado .

 Antes de utilizar esta rutina, se debe inicializar
el módulo ADC. Ver ADC_Init .
 Antes de usar la función, asegúrese de
configurar los bits TRISx apropiados para
designar pines como entradas.
Ejemplo sin signo adc_value;

...
adc_value = ADC_Get_Sample (2); // leer el valor
analógico del canal 2 del módulo ADC
ADC_Leer
Prototipo ADC_Read sin firmar ( canal corto sin firmar );
Devoluciones Se leyó un valor sin signo de 10 o 12 bits del canal

especificado (depende de MCU).
Descripción Inicializa el módulo ADC interno de PIC para que funcione

con el reloj RC. El reloj determina el período de tiempo
necesario para realizar la conversión de AD (mínimo
12TAD).
El parámetro channelrepresenta el canal desde el cual se
va a adquirir el valor analógico. Consulte la hoja de datos
correspondiente para la asignación de canal a pin.
Nota: esta función no funciona con la fuente de

referencia de tensión externa, solo con la referencia de
tensión interna.
Requiere  La MCU con módulo ADC incorporado .

 Antes de usar la función, asegúrese de
configurar los bits TRISx apropiados para
designar pines como entradas.
Ejemplo sin firma tmp;

...
tmp = ADC_Read (2); // Leer valor analógico del
canal 2
Ejemplo de biblioteca
Este código de ejemplo lee el valor analógico del canal 2 y lo muestra en PORTB y
PORTC.
Copiar código al portapapeles
unsigned int temp_res;
void main () {
ANSEL = 0x04; // Configurar el pin AN2 como analógico
ANSELH = 0; // Configurar otros pines AN como E / S
digital
C1ON_bit = 0; // Desactivar comparadores
C2ON_bit = 0;
TRISA = 0xFF; // PORTA es la entrada

TRISC = 0; // PORTC es salida
TRISB = 0; // PORTB es la salida
hacer {
temp_res = ADC_Read (2); // Obtener resultados de 10 bits de la
conversión AD AD
PORTB = temp_res; // Enviar 8 bits más bajos a PORTB
PORTC = temp_res >> 8; // Enviar 2 bits más significativos a RC1,
RC0
} while (1);
}
Conexión HW
Conexión ADC HW
Biblioteca CAN
El mikroC PRO para PIC proporciona una biblioteca (controlador) para trabajar con
el módulo CAN .
El CAN es un protocolo muy robusto que tiene detección y señalización de errores,
autocomprobación y confinamiento de fallas. Los datos CAN y los marcos
remotos defectuosos se retransmiten automáticamente, de forma similar a
Ethernet.
Las tasas de transferencia de datos dependen de la distancia. Por ejemplo, 1 Mbit /
s se puede lograr en longitudes de red inferiores a 40 m, mientras que 250 Kbit / s
se puede lograr en longitudes de red inferiores a 250 m. A mayor distancia, mayor
tasa de bits máxima que se puede alcanzar. La tasa de bits más baja definida por el
estándar es de 200 Kbit / s. Los cables utilizados son pares trenzados blindados.
CAN soporta dos formatos de mensaje:
 Formato estándar, con 11 bits identificadores, y
 Formato extendido, con 29 bits identificadores.
Importante:
 Consulte la norma CAN sobre la resistencia de terminación del

bus CAN .
 CANSetOperationMode
 CANGetOperationMode
 CANInicializar
 CANSetBaudRate
 CANSetMask
 CANSetFilter
 Puedo leer
 Puede escribir
 CANSetTxIdleLevel
CANSetOperationMode
Prototipo void CANSetOperationMode ( modo corto
sin firmar , breve wait_flag sin firmar);
Devoluciones Nada.
Descripción Establece CAN en el modo solicitado, es decir,

copias modeen CANSTAT. El parámetro modedebe ser una de
las CAN_OP_MODEconstantes (ver constantes CAN).
El parámetro wait_flagdebe ser 0 o 0xFF:
 Si se establece en 0xFF, esta es una llamada
de bloqueo; la función no "regresará" hasta
que se establezca el modo solicitado.
 Si es 0, esta es una llamada sin bloqueo. No
verifica si el módulo CAN está en el modo
solicitado o no. La persona que llama debe
usar CANGetOperationModepara verificar el
modo de operación correcto antes de realizar la
operación específica del modo.
Requiere El microcontrolador debe estar conectado

al transceptor CAN (MCP2551 o similar) que está
conectado al bus CAN .
Ejemplo CANSetOperationMode (_CAN_MODE_CONFIG, 0xFF);
CANGetOperationMode
Prototipo CANGetOperationMode () corto sin firmar ;
Devoluciones Opmode actual.
Descripción La función devuelve el modo operativo actual

del módulo CAN .

Ejemplo if (CANGetOperationMode () == _CAN_MODE_NORMAL)

{...};
CANInicializar
Prototip anular CANInitialize
o ( Char SJW, Char BRP, Char PHSEG1, CharPHSEG2, Char PR
OPSEG, Char CAN_CONFIG_FLAGS);
Devoluci Nada.
ones
Descripc Inicializa CAN . Todas las transmisiones pendientes son

ión abortadas. Establece todos los registros de máscara en 0 para
permitir todos los mensajes.
Los registros de filtro se establecen de acuerdo con el valor del
indicador:
if (CAN_CONFIG_FLAGS & _CAN_CONFIG_VALID_XTD_MSG! = 0)
// Establezca todos los filtros en XTD_MSG
else if (config & _CAN_CONFIG_VALID_STD_MSG! = 0)
// Establezca todos los filtros en STD_MSG
else
// Establezca la mitad de los filtros en el centro de
Europa.
Parámetros:
 SJW como se define en la hoja de datos (1–4)
 BRP como se define en la hoja de datos (1–64)
 PHSEG1 como se define en la hoja de datos (1–8)
 PROPSEG como se define en la hoja de datos (1–8)
 CAN_CONFIG_FLAGSse forma a partir de constantes
predefinidas (ver constantes CAN )
Requier CAN debe estar en modo Config; De lo contrario, la función será

e ignorada.
El microcontrolador debe estar conectado
al transceptor CAN (MCP2551 o similar) que está conectado
al bus CAN .
Ejemplo init = _CAN_CONFIG_SAMPLE_THRICE &

_CAN_CONFIG_PHSEG2_PRG_ON &
_CAN_CONFIG_STD_MSG &
_CAN_CONFIG_DBL_BUFFER_ON &
_CAN_CONFIG_VALID_XTD_MSG &
_CAN_CONFIG_LINE_FILTER_OFF;
...
CANInitialize (1, 1, 3, 3, 1, init); // inicializar CAN
CANSetBaudRate
Prototip void CANSetBaudRate
o ( char SJW, char BRP, char PHSEG1, char PHSEG2, char P
ROPSEG, char CAN_CONFIG_FLAGS);
Devoluc Nada.
iones
Descripc Ajusta la velocidad de transmisión de CAN . Debido a la

ión complejidad del protocolo CAN , no puede forzar simplemente
un valor de bps. En su lugar, use esta función cuando CAN esté
en modo Config. Consulte la hoja de datos para más detalles.
Parámetros:
 SJW como se define en la hoja de datos (1–4)
 BRP como se define en la hoja de datos (1–64)
 PROPSEG como se define en la hoja de datos (1–8)
 CAN_CONFIG_FLAGSse forma a partir de constantes
predefinidas (ver constantes CAN )
Requier CAN debe estar en modo Config; De lo contrario, la función será
e ignorada.
al bus CAN .
Ejemplo init = _CAN_CONFIG_SAMPLE_THRICE &

...
CANSetBaudRate (1, 1, 3, 3, 1, init);
CANSetMask
Prototipo void CANSetMask
( char CAN_MASK, valor largo , char CAN_CONFIG_FLA
GS);
Devolucione Nada.
s
Descripción La máscara de conjuntos de funciones para el filtrado

avanzado de mensajes. Dado valuees un bit ajustado a los
registros de máscara de búfer apropiados.
Parámetros:
 CAN_MASKes uno de los valores constantes
predefinidos (ver constantes CAN )
 value es el valor de registro de la máscara
 CAN_CONFIG_FLAGSselecciona el tipo de mensaje
para filtrar, ya
sea _CAN_CONFIG_XTD_MSGo_CAN_CONFIG_STD_MSG
Requiere CAN debe estar en modo Config; De lo contrario, la función

será ignorada.
al bus CAN .
Ejemplo // Establecer todos los bits de máscara en 1, es

decir, todos los bits filtrados son relevantes:
CANSetMask (_CAN_MASK_B1, -1, _CAN_CONFIG_XTD_MSG);
// Tenga en cuenta que -1 es una forma más barata de

escribir 0xFFFFFFFF.
Complemento hará el truco y lo llenará con unos.
CANSetFilter
Prototipo void CANSetFilter
( char CAN_FILTER, valor largo , charCAN_CONFIG_FLA
GS);
Devolucione Nada.
s
Descripción Función fija el filtro de mensajes. Dado valuees un bit

ajustado a los registros de máscara de búfer apropiados.
Parámetros:
 CAN_FILTERes uno de los valores constantes
predefinidos (ver constantes CAN )
 value es el valor de registro del filtro
 CAN_CONFIG_FLAGSselecciona el tipo de mensaje
para filtrar, ya
sea _CAN_CONFIG_XTD_MSGo_CAN_CONFIG_STD_MSG
Requiere CAN debe estar en modo Config; De lo contrario, la función

será ignorada.
al bus CAN .
Ejemplo // Establezca la identificación del filtro B1_F1 en

3:
CANSetFilter (_CAN_FILTER_B1_F1, 3,
_CAN_CONFIG_XTD_MSG);
Puedo leer
Prototipo char CANRead ( long * id, char * data, char *
datalen, char * CAN_RX_MSG_FLAGS);
Devoluciones Mensaje del búfer de recepción o cero si no se encuentra

ningún mensaje.
Descripción La función lee el mensaje del búfer de recepción. Si se

encuentra al menos un búfer de recepción completo, se
extrae y se devuelve. Si no se encuentra ninguno, la
función devuelve cero.
Parámetros:
 id es identificador de mensaje
 data Es una matriz de bytes de hasta 8 bytes
de longitud.
 datalen es la longitud de los datos, de 1 a 8.
 CAN_RX_MSG_FLAGSes el valor formado a partir
de constantes (ver constantes CAN )
Requiere CAN debe estar en modo en el que la recepción sea

posible.
Ejemplo char rcv, rx, len, data [8];

ID larga
// ...
rx = 0;
// ...
rcv = CANRead (id, data, len, rx);
Puede escribir
Prototipo unsigned short CanWrite
( largo Identificación, carbón de leña de datos
*, carbón de leña datalen, carbón de
leña CAN_TX_MSG_FLAGS);
Devoluciones Devuelve cero si el mensaje no se puede poner en cola

(búfer lleno).
Descripción Si se encuentra al menos un búfer de transmisión vacío, la

función envía un mensaje en la cola para su transmisión. Si
el búfer está lleno, la función devuelve 0.
Parámetros:
 ides el identificador de mensaje CAN. Solo se
pueden usar 11 o 29 bits según el tipo de
mensaje (estándar o extendido)
 data Es una matriz de bytes de hasta 8 bytes
de longitud.
 datalen es la longitud de los datos de 1 a 8
 CAN_TX_MSG_FLAGSes el valor formado a partir
de constantes (ver constantes CAN )
Requiere CAN debe estar en modo normal.

Ejemplo char tx, datos;

ID larga
// ...
tx = _CAN_TX_PRIORITY_0 &
_CAN_TX_XTD_FRAME;
// ...
CANWrite (id, data, 2, tx);
CANSetTxIdleLevel
Prototipo void CANSetTxIdleLevel ( char driveHighState);
Devoluciones Nada.
Descripción Esta función establece el estado del pin CANTX cuando es

recesivo.
Parámetros:
 driveHighState:Estado del pin CANTX. Valores
válidos:
Descripción Biblioteca predefinida const
El pin CANTX
conducirá
VDD cuando
sea recesivo.
Úselo cuando
use un bus
diferencial _CAN_DRIVE_HIGH_STATE_ENABLE
para evitar la
interferencia
de señal en
CANTX de
otros pines
cercanos.
El pin CANTX
será de tres
estados _CAN_DRIVE_HIGH_STATE_DISABLE
cuando sea
recesivo.

Ejemplo CANSetTxIdleLevel (_CAN_DRIVE_HIGH_STATE_ENABLE);
Constantes CAN
Hay una serie de constantes predefinidas en la biblioteca CAN . Para poder utilizar
la biblioteca de manera efectiva, debe estar familiarizado con estos. Es posible que
desee comprobar el ejemplo al final del capítulo.
CAN_OP_MODE
CAN_OP_MODElas constantes definen el modo de operación CAN . La
función CANSetOperationModeespera uno de estos como su argumento:
const char
_CAN_MODE_BITS = 0xE0, // Use esto para acceder a los bits de modo
operativo
_CAN_MODE_NORMAL = 0x00,
_CAN_MODE_SLEEP = 0x20,
_CAN_MODE_LOOP = 0x40,
_CAN_MODE_LISTEN = 0x60,
_CAN_MODE_CONFIG = 0x80;
CAN_CONFIG_FLAGS
CAN_CONFIG_FLAGSlas constantes definen banderas relacionadas con la configuración
del módulo CAN . Funciona CANInitializey CANSetBaudRateespera uno de estos (o
una combinación bit a bit) como su argumento:
const char
_CAN_CONFIG_DEFAULT = 0xFF, // 11111111
_CAN_CONFIG_PHSEG2_PRG_BIT = 0x01,
_CAN_CONFIG_PHSEG2_PRG_ON = 0xFF, // XXXXXXX1
_CAN_CONFIG_PHSEG2_PRG_OFF = 0xFE, // XXXXXXX0
_CAN_CONFIG_LINE_FILTER_BIT = 0x02,
_CAN_CONFIG_LINE_FILTER_ON = 0xFF, // XXXXXX1X
_CAN_CONFIG_LINE_FILTER_OFF = 0xFD, // XXXXXX0X
_CAN_CONFIG_SAMPLE_BIT = 0x04,
_CAN_CONFIG_SAMPLE_ONCE = 0xFF, // XXXXX1XX
_CAN_CONFIG_SAMPLE_THRICE = 0xFB, // XXXXX0XX
_CAN_CONFIG_MSG_TYPE_BIT = 0x08,
_CAN_CONFIG_STD_MSG = 0xFF, // XXXX1XXX
_CAN_CONFIG_XTD_MSG = 0xF7, // XXXX0XXX
_CAN_CONFIG_DBL_BUFFER_BIT = 0x10,
_CAN_CONFIG_DBL_BUFFER_ON = 0xFF, // XXX1XXXX
_CAN_CONFIG_DBL_BUFFER_OFF = 0xEF, // XXX0XXXX
_CAN_CONFIG_MSG_BITS = 0x60,
_CAN_CONFIG_ALL_MSG = 0xFF, // X11XXXXX
_CAN_CONFIG_VALID_XTD_MSG = 0xDF, // X10XXXXX
_CAN_CONFIG_VALID_STD_MSG = 0xBF, // X01XXXXX
_CAN_CONFIG_ALL_VALID_MSG = 0x9F; // X00XXXXX
Puede usar AND ( &) a nivel de bit para formar un byte de configuración de estos
valores. Por ejemplo:
init = _CAN_CONFIG_SAMPLE_THRICE &

...
CANInitialize (1, 1, 3, 3, 1, init); // inicializar CAN
CAN_TX_MSG_FLAGS
CAN_TX_MSG_FLAGSLas banderas están relacionadas con la transmisión de
un mensaje CAN :
const char
_CAN_TX_PRIORITY_BITS = 0x03,
_CAN_TX_PRIORITY_0 = 0xFC, // XXXXXX00
_CAN_TX_PRIORITY_1 = 0xFD, // XXXXXX01
_CAN_TX_PRIORITY_2 = 0xFE, // XXXXXX10
_CAN_TX_PRIORITY_3 = 0xFF, // XXXXXX11
_CAN_TX_FRAME_BIT = 0x08,
_CAN_TX_STD_FRAME = 0xFF, // XXXXX1XX
_CAN_TX_XTD_FRAME = 0xF7, // XXXXX0XX
_CAN_TX_RTR_BIT = 0x40,
_CAN_TX_NO_RTR_FRAME = 0xFF, // X1XXXXXX
_CAN_TX_RTR_FRAME = 0xBF; // X0XXXXXX
Puede usar AND ( &) a nivel de bits para ajustar los indicadores apropiados. Por
ejemplo:
// valor del formulario que se utilizará con CANSendMessage:

send_config = _CAN_TX_PRIORITY_0 &
_CAN_TX_XTD_FRAME &
_CAN_TX_NO_RTR_FRAME;
...
CANSendMessage (id, data, 1, send_config);
CAN_RX_MSG_FLAGS
CAN_RX_MSG_FLAGSSon banderas relacionadas con la recepción del mensaje CAN . Si
se establece un bit particular; el significado correspondiente es VERDADERO o de lo
contrario será FALSO.
const char
_CAN_RX_FILTER_BITS = 0x07, // Use esto para acceder a los bits de
filtro
_CAN_RX_FILTER_1 = 0x00,
_CAN_RX_OVERFLOW = 0x08, // Establecer si no, se borra Desbordado
_CAN_RX_INVALID_MSG = 0x10, // Establecer si no, se borra inválida
_CAN_RX_XTD_FRAME = 0x20, // Establecer si el mensaje XTD no, se
borra
_CAN_RX_RTR_FRAME = 0x40, // Establecer si el mensaje RTR no, se
borra
_CAN_RX_DBL_BUFFERED = 0x80; // Establecer si este mensaje era
hardware de doble búfer
ejemplo:
if (MsgFlag & _CAN_RX_OVERFLOW! = 0) {

...
// Se ha producido un desbordamiento del receptor.
// Hemos perdido nuestro mensaje anterior.
}
CAN_MASK
CAN_MASKLas constantes definen códigos de máscara. La función CANSetMaskespera
uno de estos como su argumento:
# const char
_CAN_MASK_B1 = 0,
_CAN_MASK_B2 = 1;
CAN_FILTER
CAN_FILTERLas constantes definen códigos de filtro. La función CANSetFilterespera
uno de estos como su argumento:
const char
_CAN_FILTER_B1_F1 = 0,
_CAN_FILTER_B2_F4 = 5;
Esta es una demostración simple del uso de rutinas de la Biblioteca CAN . El primer
nodo inicia la comunicación con el segundo nodo enviando algunos datos a su
dirección. El segundo nodo responde devolviendo los datos incrementados en 1. El
primer nodo luego hace lo mismo y envía los datos incrementados de vuelta al
segundo nodo, etc.
Código para el primer nodo CAN:
unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // puede

banderas
sin firmar char Rx_Data_Len; // longitud
de los datos recibidos en bytes
char RxTx_Data [8]; // can rx /
tx data buffer
char Msg_Rcvd; // indicador
de recepción
const long ID_1st = 12111, ID_2nd = 3; // ID de nodo
largo Rx_ID;
void main () {
PORTC = 0; // borrar
PORTC
TRISC = 0; // establece
PORTC como salida
Can_Init_Flags = 0; //
Can_Send_Flags = 0; // borrar las
banderas
Can_Rcv_Flags = 0; //
Can_Send_Flags = _CAN_TX_PRIORITY_0 & // valor de

formulario que se utilizará
_CAN_TX_XTD_FRAME & // con
CANWrite
Can_Init_Flags = _CAN_CONFIG_SAMPLE_THRICE & // valor de

_CAN_CONFIG_PHSEG2_PRG_ON & // con
CANInit
_CAN_CONFIG_XTD_MSG &
_CAN_CONFIG_VALID_XTD_MSG;
CANInitialize (1,3,3,3,1, Can_Init_Flags); //

Inicializar el módulo CAN
CANSetOperationMode (_CAN_MODE_CONFIG, 0xFF); //
establecer el modo CONFIGURACIÓN
CANSetMask (_CAN_MASK_B1, -1, _CAN_CONFIG_XTD_MSG); //
establece todos los bits de mask1 a unos
establece todos los bits de mask2 a los
CANSetFilter (_CAN_FILTER_B2_F4, ID_2nd, _CAN_CONFIG_XTD_MSG); //
establecer la id del filtro B2_F4 a la segunda ID de nodo
CANSetOperationMode (_CAN_MODE_NORMAL, 0xFF); // establece

el modo NORMAL
RxTx_Data [0] = 9; // configurar

los datos iniciales para ser enviados
CANWrite (ID_1st, RxTx_Data, 1, Can_Send_Flags); // enviar

mensaje inicial
while (1) {
// interminable bucle
Msg_Rcvd = CANRead (& Rx_ID, RxTx_Data, & Rx_Data_Len, &
Can_Rcv_Flags); // recibir mensaje
si ((Rx_ID == ID_2nd) && Msg_Rcvd) {
// si el mensaje recibió la identificación de verificación
PORTC = RxTx_Data [0];
// identificación correcta, datos de salida en PORTC
RxTx_Data [0] ++;
// incrementar datos recibidos
Delay_ms (10);
CANWrite (ID_1st, RxTx_Data, 1, Can_Send_Flags);
// devolver datos incrementados
}
}
}
Código para el segundo nodo CAN:


banderas
tx data buffer
de recepción
largo Rx_ID;
void main () {
PORTC = 0; // borrar
PORTC
TRISC = 0; // establece
PORTC como salida
Can_Send_Flags = 0; // borrar las
banderas
Can_Send_Flags = _CAN_TX_PRIORITY_0 & // valor de

_CAN_TX_XTD_FRAME & // con
CANWrite
Can_Init_Flags = _CAN_CONFIG_SAMPLE_THRICE & // valor de

_CAN_CONFIG_PHSEG2_PRG_ON & // con
CANInit
_CAN_CONFIG_XTD_MSG &
CANInitialize (1,3,3,3,1, Can_Init_Flags); //

inicializar el módulo CAN externo
CANSetOperationMode (_CAN_MODE_CONFIG, 0xFF); //
establecer el modo CONFIGURACIÓN
establece todos los bits de mask1 a unos
CANSetFilter (_CAN_FILTER_B2_F3, ID_1st, _CAN_CONFIG_XTD_MSG); //
establecer la id del filtro B2_F3 en el primer ID de nodo
CANSetOperationMode (_CAN_MODE_NORMAL, 0xFF); // establece

el modo NORMAL
while (1) {
Msg_Rcvd = CANRead (& Rx_ID, RxTx_Data, & Rx_Data_Len, &
si ((Rx_ID == ID_1st) && Msg_Rcvd) {
PORTC = RxTx_Data [0];
RxTx_Data [0] ++;
// incrementar los datos recibidos
CANWrite (ID_2nd, RxTx_Data, 1, Can_Send_Flags);
}
}
}
Conexión HW
Ejemplo de interfaz de transceptor CAN con MCU y bus

Biblioteca CANSPI
El módulo SPI está disponible con varias MCU compatibles con PIC. El mikroC PRO
para PIC proporciona una biblioteca (controlador) para trabajar con los tableros
adicionales CANSPI de mikroElektronika (con MCP2515 o MCP2510) a través de
la interfaz SPI .
El CAN es un protocolo muy robusto que tiene detección y señalización de errores,
autocomprobación y confinamiento de fallas. Los datos CAN y los marcos
remotos defectuosos se retransmiten automáticamente, de forma similar a
Ethernet.
En el mikroC PRO para PIC, cada rutina de la biblioteca CAN tiene su
propia contraparte CANSPI con una sintaxis idéntica. Para obtener más información
sobre la red de área del controlador, consulte la biblioteca CAN . Tenga en cuenta
que una velocidad de comunicación efectiva depende de SPI y ciertamente es más
lenta que la CAN "real" .
Las tasas de transferencia de datos dependen de la distancia. Por ejemplo, 1 Mbit /
s se puede lograr en longitudes de red inferiores a 40 m, mientras que 250 Kbit / s
se puede lograr en longitudes de red inferiores a 250 m. A mayor distancia, mayor
tasa de bits máxima que se puede alcanzar. La tasa de bits más baja definida por el
estándar es de 200 Kbit / s. Los cables utilizados son pares trenzados blindados.
CAN soporta dos formatos de mensaje:
 Formato estándar, con 11 bits identificadores y
 Formato extendido, con 29 bits identificadores.
Importante:
 Consulte la norma CAN sobre la resistencia de terminación del
bus CAN .
 Una velocidad de comunicación CANSPI efectiva depende de SPI y
ciertamente es más lenta que la CAN "real" .
 La biblioteca utiliza el módulo SPI para la comunicación. El usuario debe
inicializar el módulo SPI apropiado antes de usar la biblioteca CANSPI .
 Para MCU con dos módulos SPI es posible inicializar ambos y luego
cambiar usando la rutina SPI_Set_Active .
 El módulo CANSPI se refiere a la placa complementaria CANSPI de
mikroElektronika conectada al módulo SPI de MCU .
Árbol de la dependencia de la biblioteca
Dependencias externas de la biblioteca CANSPI

Las siguientes
variables deben
Descripció
definirse en todos los Ejemplo:
n:
proyectos usando
labiblioteca CANSPI :
Chip de
extern sfr
sbitCanSpi_CS; selección de sbit CanSpi_CS atRC0_bit;
línea.
extern sfr Restablecer sbit CanSpi_Rst atRC2_bit;
sbitCanSpi_Rst; línea.
extern sfr Dirección
sbitCanSpi_CS_Direction at TRISC0_
sbitCanSpi_CS_Directio del pin Chip bit;
n; Select.

sbitCanSpi_Rst_Direction at TRISC2
sbitCanSpi_Rst_Directi del pin de _bit;
on; reinicio.
 CANSPISetOperationMode
 CANSPIGetOperationMode
 CANSPIInicializar
 CANSPISetBaudRate
 CANSPISetMask
 CANSPISetFilter
 CANSPIRead
 CANSPIWrite
CANSPISetOperationMode
Prototipo void CANSPISetOperationMode
( Char modo, Char WAIT);
Devoluciones Nada.
Descripción Establece el módulo CANSPI en el modo solicitado.

Parámetros:
 mode:Modo de operación del módulo
CANSPI. Valores
válidos: CANSPI_OP_MODEconstantes
(ver constantes CANSPI ).
 WAIT:Solicitud de verificación de cambio de
modo CANSPI. Si WAIT == 0, la llamada es no
bloqueante. La función no verifica si el módulo
CANSPI se cambió al modo solicitado o no. La
persona que llama debe
usar CANSPIGetOperationModepara verificar el
modo de operación correcto antes de realizar la
operación específica del modo. Si WAIT != 0, la
llamada está bloqueando, la función no
"regresará" hasta que se establezca el modo
solicitado.
Requiere Las rutinas CANSPI solo son compatibles con las MCU con
el módulo SPI .
La MCU debe estar correctamente conectada a la placa
CANSPI Extra de mikroElektronika o hardware similar. Vea
el ejemplo de conexión en la parte inferior de esta página.
Ejemplo // configura el módulo CANSPI en modo de

configuración (espera dentro de
CANSPISetOperationMode hasta que se establezca este
modo)
CANSPISetOperationMode (_CANSPI_MODE_CONFIG, 0xFF);
CANSPIGetOperationMode
Prototipo char CANSPIGetOperationMode ();
Devoluciones Modo de funcionamiento actual.
Descripción La función devuelve el modo de operación actual

del módulo CANSPI . Verifique
las CANSPI_OP_MODEconstantes (vea constantes CANSPI ) o
la hoja de datos del dispositivo para los códigos de modo
de operación.
Requiere Las rutinas CANSPI solo son compatibles con las MCU con
el módulo SPI .
Ejemplo // comprueba si el módulo CANSPI está en modo Normal

y si está haciendo algo.
if (CANSPIGetOperationMode () ==
_CANSPI_MODE_NORMAL) {
...
}
CANSPIInicializar
Prototip void CANSPIInitialize
ROPSEG, char CANSPI_CONFIG_FLAGS);
Devoluc Nada.
iones
Descrip Inicializa el módulo CANSPI .

ción El controlador CAN independiente en el módulo CANSPI está
configurado para:
 Deshabilitar captura CAN
 Continuar la operación CAN en modo inactivo
 No abortar las transmisiones pendientes.
 Reloj Fcan: 4 * Tcy (Fosc)
 La velocidad de transmisión se establece de acuerdo
con los parámetros dados
 Modo CAN: Normal
 Los ID de registros de filtro y máscara se establecen
en cero
 El filtro y el tipo de cuadro de mensaje de máscara
se establecen de acuerdo con
el CANSPI_CONFIG_FLAGSvalor
SAM, SEG2PHTS, WAKFILY DBENbits se establecen de acuerdo
con CANSPI_CONFIG_FLAGSel valor.
Parámetros:
 SJWcomo se define en la hoja de datos del
controlador CAN
 BRPcomo se define en la hoja de datos del
controlador CAN
 PHSEG1como se define en la hoja de datos del
controlador CAN
controlador CAN
 PROPSEGcomo se define en la hoja de datos del
controlador CAN
 CANSPI_CONFIG_FLAGSse forma a partir de constantes
predefinidas (ver constantes CANSPI )
Requier Variables globales :

e  CanSpi_CS: Línea Chip Select
 CanSpi_Rst: Restablecer línea
 CanSpi_CS_Direction: Dirección del pin Chip Select
 CanSpi_Rst_Direction: Dirección del pin de reinicio
Debe ser definido antes de usar esta función.
Las rutinas CANSPI solo son compatibles con las MCU con
el módulo SPI .
El módulo SPI necesita ser inicializado. Ver
las rutinas SPIx_Init y SPIx_Init_Advanced .
CANSPI Extra de mikroElektronika o hardware similar. Vea el
ejemplo de conexión en la parte inferior de esta página.
Ejemplo // Conexiones del módulo

CANSPI sbit CanSpi_CS at RC0_bit;
sbit CanSpi_CS_Direction en TRISC0_bit;
sbit CanSpi_Rst en RC2_bit;
sbit CanSpi_Rst_Direction en TRISC2_bit;
// Terminar las conexiones del módulo CANSPI
// inicialice el módulo CANSPI con los indicadores de

velocidad de transmisión y de mensajes adecuados junto
con las reglas de muestreo
char CanSPi_Init_Flags;
...
CanSPi_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE & //
valor de formulario que se utilizará
_CANSPI_CONFIG_PHSEG2_PRG_ON & //
con CANSPIInitialize
_CANSPI_CONFIG_XTD_MSG &
_CANSPI_CONFIG_DBL_BUFFER_ON &
_CANSPI_CONFIG_VALID_XTD_MSG;
...
SPI1_Init (); //
inicializar el módulo SPI
CANSPIInitialize (1,3,3,3,1, CanSpi_Init_Flags); //
inicializar el módulo CANSPI externo
CANSPISetBaudRate
Prototip void CANSPISetBaudRate
ROPSEG, char CANSPI_CONFIG_FLAGS);
Devoluc Nada.
iones
Descrip Establece la velocidad en baudios del módulo CANSPI . Debido a

ción la complejidad del protocolo CAN , no puede forzar simplemente
un valor de bps. En su lugar, use esta función cuando
el módulo CANSPI esté en modo Config.
SAM, SEG2PHTSy los WAKFILbits se establecen de acuerdo
al CANSPI_CONFIG_FLAGSvalor. Consulte la hoja de datos para
más detalles.
Parámetros:
 SJWcomo se define en la hoja de datos del
controlador CAN
 BRPcomo se define en la hoja de datos del
controlador CAN
controlador CAN
controlador CAN
 PROPSEGcomo se define en la hoja de datos del
controlador CAN
 CANSPI_CONFIG_FLAGSse forma a partir de constantes
predefinidas (ver constantes CANSPI )
Requier El módulo CANSPI debe estar en modo Config. De lo contrario, la

e función se ignorará. Ver CANSPISetOperationMode .
el módulo SPI .
Ejemplo // establece la velocidad de transmisión requerida y las

reglas de muestreo
char canspi_config_flags;
...
CANSPISetOperationMode (CANSPI_MODE_CONFIG, 0xFF);
// establecer el modo CONFIGURACIÓN (el módulo CANSPI
debe estar en modo de configuración para la configuración
de la velocidad en baudios)
canspi_config_flags = _CANSPI_CONFIG_SAMPLE_THRICE &
_CANSPI_CONFIG_PHSEG2_PRG_ON &
_CANSPI_CONFIG_STD_MSG &
_CANSPI_CONFIG_VALID_XTD_MSG &
_CANSPI_CONFIG_LINE_FILTER_OFF;
CANSPISetBaudRate (1, 1, 3, 3, 1, canspi_config_flags);
CANSPISetMask
Prototipo void CANSPISetMask
( char CANSPI_MASK, long val, char CANSPI_CONFIG_FL
AGS);
Devolucion Nada.
es
Descripción Configura la máscara para el filtrado avanzado de

mensajes. El parámetro valuese ajusta en bits a los
registros de máscara apropiados.
Parámetros:
 CANSPI_MASK: Número de máscara del
módulo CANSPI . Valores
válidos: CANSPI_MASKconstantes (ver constantes
CANSPI )
 val: valor de registro de máscara
 CANSPI_CONFIG_FLAGS:Selecciona el tipo de
mensaje a filtrar. Valores válidos:
 _CANSPI_CONFIG_ALL_VALID_MSG,
 _CANSPI_CONFIG_MATCH_MSG_TYPE &
_CANSPI_CONFIG_STD_MSG,
_CANSPI_CONFIG_XTD_MSG.
(ver constantes CANSPI )
Requiere El módulo CANSPI debe estar en modo Config. De lo

contrario, la función se
ignorará. Ver CANSPISetOperationMode .
el módulo SPI .
Ejemplo // establece la máscara de filtro y el valor de tipo

de mensaje apropiados
debe estar en el modo de configuración para la
configuración de la máscara)
// Establecer todos los bits de máscara B1 en 1 (todos

los bits filtrados son relevantes):
// Tenga en cuenta que -1 es una forma más barata de
escribir 0xFFFFFFFF.
// Complemento hará el truco y lo llenará con unos.
CANSPISetMask (_CANSPI_MASK_B1, -1,
_CANSPI_CONFIG_MATCH_MSG_TYPE &
_CANSPI_CONFIG_XTD_MSG);
CANSPISetFilter
Prototipo void CANSPISetFilter
( char CANSPI_FILTER, long val, char CANSPI_CONFIG_
FLAGS);
Devolucion Nada.
es
Descripción Configura el filtro de mensajes. El parámetro valuese ajusta

en bits a los registros de filtro apropiados.
Parámetros:
 CANSPI_FILTER: Número de filtro del
módulo CANSPI . Valores
válidos: CANSPI_FILTERconstantes
 val: valor de registro de filtro
 CANSPI_CONFIG_FLAGS:Selecciona el tipo de
mensaje a filtrar. Valores válidos:
 _CANSPI_CONFIG_ALL_VALID_MSG,
_CANSPI_CONFIG_STD_MSG,
_CANSPI_CONFIG_XTD_MSG.
Requiere El módulo CANSPI debe estar en modo Config. De lo
contrario, la función se
ignorará. Ver CANSPISetOperationMode .
el módulo SPI .
Ejemplo // establece el valor de filtro apropiado y el tipo de

mensaje
debe estar en modo de configuración para la
configuración del filtro)
/ * Establecer id del filtro B1_F1 a 3: * /

CANSPISetFilter (_CANSPI_FILTER_B1_F1, 3,
_CANSPI_CONFIG_XTD_MSG);
CANSPIRead
Prototipo char CANSPIRead ( long * id, char *
rd_data, char * data_len, char *
CANSPI_RX_MSG_FLAGS);
Devoluciones  0 si no se recibe nada

 0xFF si uno de los buffers de recepción está
lleno (mensaje recibido)
Descripción Si se encuentra al menos un búfer de recepción completo,

se procesará de la siguiente manera:
 El ID de mensaje se recupera y almacena en la
ubicación proporcionada por el idparámetro
 Los datos del mensaje se recuperan y
almacenan en un búfer proporcionado por
el rd_dataparámetro
 La longitud del mensaje se recupera y
almacena en la ubicación proporcionada por
el data_lenparámetro
 Los indicadores de mensaje se recuperan y
almacenan en la ubicación proporcionada por
el CANSPI_RX_MSG_FLAGSparámetro
Parámetros:
 id: identificador de mensaje dirección de
almacenamiento
 rd_data: búfer de datos (una matriz de bytes
de hasta 8 bytes de longitud)
 data_len: Dirección de almacenamiento de
longitud de datos.
 CANSPI_RX_MSG_FLAGS: mensaje señala la
dirección de almacenamiento
Requiere El módulo CANSPI debe estar en un modo en el que la

recepción sea posible. Ver CANSPISetOperationMode .
el módulo SPI .
Ejemplo // compruebe el módulo CANSPI para los mensajes

recibidos. Si alguno fue recibido haz algo.
char msg_rcvd, rx_flags, data_len;
datos de carácter [8];
long msg_id;
...
CANSPISetOperationMode (_CANSPI_MODE_NORMAL, 0xFF);
// establecer el modo NORMAL (el módulo CANSPI debe
estar en el modo en el que es posible recibir)
...
rx_flags = 0;
// borrar las banderas de mensaje
if (msg_rcvd = CANSPIRead (msg_id, data, data_len,
rx_flags)) {
...
}
CANSPIWrite
Prototipo char CANSPIWrite ( id largo , char *
wr_data, char data_len, char CANSPI_TX_MSG_FLAGS);
Devoluciones  0 si todos los buffers de transmisión están

ocupados
 0xFF si al menos un búfer de transmisión está
disponible
Descripción Si se encuentra al menos un búfer de transmisión vacío, la

función envía un mensaje en la cola para su transmisión.
Parámetros:
 id:Identificador de mensaje CAN . Valores
válidos: valores de 11 o 29 bits, según el tipo
de mensaje (estándar o extendido)
 wr_data: Datos a enviar (una matriz de bytes
de hasta 8 bytes de longitud)
 data_len:longitud de datos. Valores válidos: 1
a 8.
 CANSPI_RX_MSG_FLAGS: banderas de mensaje
Requiere El módulo CANSPI debe estar en modo en el que la

transmisión sea posible. Ver CANSPISetOperationMode .
el módulo SPI .
Ejemplo // enviar mensaje extendida mensaje CAN con el ID y

datos apropiados
de char tx_flags;
datos de carácter [8];
long msg_id;
...
// establecer el modo NORMAL (CANSPI debe estar en
el modo en el que la transmisión es posible)
tx_flags = _CANSPI_TX_PRIORITY_0 &

_CANSPI_TX_XTD_FRAME; // establecer
banderas de mensaje
CANSPIWrite (msg_id, datos, 2, tx_flags);
Constantes CANSPI
Hay una serie de constantes predefinidas en la biblioteca CANSPI . Debe estar
familiarizado con ellos para poder utilizar la biblioteca de manera efectiva. Verifique
el ejemplo al final del capítulo.
CANSPI_OP_MODE
Las CANSPI_OP_MODEconstantes definen el modo de operación CANSPI . La
función CANSPISetOperationMode espera uno de estos como argumento:
const char
_CANSPI_MODE_BITS = 0xE0, // Use esto para acceder a los bits de
modo operativo
_CANSPI_MODE_NORMAL = 0x00,
_CANSPI_MODE_SLEEP = 0x20,
_CANSPI_MODE_LOOP = 0x40,
_CANSPI_MODE_LISTEN = 0x60,
_CANSPI_MODE_CONFIG = 0x80;
CANSPI_CONFIG_FLAGS
Las CANSPI_CONFIG_FLAGSconstantes definen banderas relacionadas con
la configuración del módulo CANSPI . Las
funciones CANSPIInitialize , CANSPISetBaudRate , CANSPISetMask y CANSPISetFilt
eresperan uno de estos (o una combinación bit a bit) como su argumento:
const char
_CANSPI_CONFIG_DEFAULT = 0xFF, // 11111111
_CANSPI_CONFIG_PHSEG2_PRG_BIT = 0x01,
_CANSPI_CONFIG_PHSEG2_PRG_ON = 0xFF, // XXXXXXX1
_CANSPI_CONFIG_PHSEG2_PRG_OFF = 0xFE, // XXXXXXX0
_CANSPI_CONFIG_LINE_FILTER_BIT = 0x02,
_CANSPI_CONFIG_LINE_FILTER_ON = 0xFF, // XXXXXX1X
_CANSPI_CONFIG_LINE_FILTER_OFF = 0xFD, // XXXXXX0X
_CANSPI_CONFIG_SAMPLE_BIT = 0x04,
_CANSPI_CONFIG_SAMPLE_ONCE = 0xFF, // XXXXX1XX
_CANSPI_CONFIG_SAMPLE_THRICE = 0xFB, // XXXXX0XX
_CANSPI_CONFIG_MSG_TYPE_BIT = 0x08,
_CANSPI_CONFIG_STD_MSG = 0xFF, // XXXX1XXX
_CANSPI_CONFIG_XTD_MSG = 0xF7, // XXXX0XXX
_CANSPI_CONFIG_DBL_BUFFER_BIT = 0x10,
_CANSPI_CONFIG_DBL_BUFFER_ON = 0xFF, // XXX1XXXX
_CANSPI_CONFIG_DBL_BUFFER_OFF = 0xEF, // XXX0XXXX
_CANSPI_CONFIG_MSG_BITS = 0x60,
_CANSPI_CONFIG_ALL_MSG = 0xFF, // X11XXXXX
_CANSPI_CONFIG_VALID_XTD_MSG = 0xDF, // X10XXXXX
_CANSPI_CONFIG_VALID_STD_MSG = 0xBF, // X01XXXXX
_CANSPI_CONFIG_ALL_VALID_MSG = 0x9F; // X00XXXXX
Puede usar AND ( &) a nivel de bit para formar un byte de configuración de estos
valores. Por ejemplo:
init = _CANSPI_CONFIG_SAMPLE_THRICE &

_CANSPI_CONFIG_PHSEG2_PRG_ON &
_CANSPI_CONFIG_STD_MSG &
...
CANSPIInitialize (1, 1, 3, 3, 1, init); // inicializa CANSPI
CANSPI_TX_MSG_FLAGS
CANSPI_TX_MSG_FLAGSLas banderas están relacionadas con la transmisión de
un mensaje CAN :
const char
_CANSPI_TX_PRIORITY_BITS = 0x03,
_CANSPI_TX_PRIORITY_0 = 0xFC, // XXXXXX00
_CANSPI_TX_PRIORITY_1 = 0xFD, // XXXXXX01
_CANSPI_TX_PRIORITY_2 = 0xFE, // XXXX10
_CANSPI_TX_PRIORITY_3 = 0xFF, // XXXXXX
_CANSPI_TX_FRAME_BIT = 0x08,
_CANSPI_TX_STD_FRAME = 0xFF, // XXXXX1XX
_CANSPI_TX_XTD_FRAME = 0xF7, // XXXXX0XX
_CANSPI_TX_RTR_BIT = 0x40,
_CANSPI_TX_NO_RTR_FRAME = 0xFF, // X1XXXXXX
_CANSPI_TX_RTR_FRAME = 0xBF; // X0XXXXXX
ejemplo:
/ * valor de formulario que se utilizará como indicador de mensaje de

envío: * /
send_config = _CANSPI_TX_PRIORITY_0 &
_CANSPI_TX_XTD_FRAME &
_CANSPI_TX_NO_RTR_FRAME;
...
CANSPIWrite (id, data, 1, send_config);
CANSPI_RX_MSG_FLAGS
CANSPI_RX_MSG_FLAGSSon banderas relacionadas con la recepción
del mensaje CAN . Si se establece un bit en particular, el significado
correspondiente es VERDADERO o, de lo contrario, será FALSO.
const char
_CANSPI_RX_FILTER_BITS = 0x07, // Use esto para acceder a los bits
de filtro
_CANSPI_RX_FILTER_1 = 0x00,
_CANSPI_RX_OVERFLOW = 0x08, // Establecer si no, se borra

Desbordado
_CANSPI_RX_INVALID_MSG = 0x10, // Establecer si no, se borra
inválida
_CANSPI_RX_XTD_FRAME = 0x20, // Establecer si el mensaje XTD no, se
borra
_CANSPI_RX_RTR_FRAME = 0x40, // Establecer si el mensaje RTR no, se
borra
_CANSPI_RX_DBL_BUFFERED = 0x80; // Establecer si este mensaje era
hardware de doble búfer
ejemplo:
if (MsgFlag & _CANSPI_RX_OVERFLOW! = 0) {

...
// Se ha producido un desbordamiento del receptor.
// Hemos perdido nuestro mensaje anterior.
}
CANSPI_MASK
Las CANSPI_MASKconstantes definen códigos de máscara. La
función CANSPISetMask espera uno de estos como argumento:
const char
_CANSPI_MASK_B1 = 0,
_CANSPI_MASK_B2 = 1;
CANSPI_FILTER
Las CANSPI_FILTERconstantes definen códigos de
filtro. Funciones CANSPISetFilter espera uno de estos como argumento:
const char
_CANSPI_FILTER_B1_F1 = 0,
_CANSPI_FILTER_B2_F4 = 5;
Esta es una demostración simple del uso de las rutinas de la biblioteca CANSPI . El
primer nodo inicia la comunicación con el segundo nodo enviando algunos datos a
su dirección. El segundo nodo responde devolviendo los datos incrementados en 1.
El primer nodo luego hace lo mismo y envía los datos incrementados de vuelta al
segundo nodo, etc.
Código para el primer nodo CANSPI:

banderas
tx data buffer
de recepción
largo Rx_ID;
// Conexiones del módulo

void main () {
ANSEL = 0; // Configurar
pines AN como E / S digital
ANSELH = 0;
PORTB = 0; // borrar
PORTB
TRISB = 0; // establece
PORTB como salida
Can_Send_Flags = 0; // borrar
las banderas
Can_Send_Flags = _CANSPI_TX_PRIORITY_0 & // valor de

_CANSPI_TX_XTD_FRAME & // con
CANSPIWrite
Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE & // Valor de

_CANSPI_CONFIG_PHSEG2_PRG_ON & // con
CANSPIInit
_CANSPI_CONFIG_VALID_XTD_MSG;
SPI1_Init (); //
inicializar el módulo SPI1
CANSPIInitialize (1,3,3,3,1, Can_Init_Flags); //

Inicializar el módulo
CANSPI externo CANSPISetOperationMode (_CANSPI_MODE_CONFIG, 0xFF);
// establece el modo CONFIGURACIÓN
CANSPISetMask (_CANSPI_MASK_B1, -1, _CANSPI_CONFIG_XTD_MSG); //
establece todos los bits de mask1 en unos
CANSPISetMask (_CANSPI_MASK_B2, -1, _CANSPI_CONFIG_XTD_MSG); //
CANSPISetFilter (_CANSPI_FILTER_B2_F4, ID_2nd, _CANSPI_CONFIG_XTD_MSG);
// establecer la id del filtro B2_F4 a la segunda ID de nodo
CANSPISetOperationMode (_CANSPI_MODE_NORMAL, 0xFF); //

establece el modo NORMAL
RxTx_Data [0] = 9; //
configurar los datos iniciales para ser enviados
CANSPIWrite (ID_1st, RxTx_Data, 1, Can_Send_Flags); //

enviar mensaje inicial
while (1) {
Msg_Rcvd = CANSPIRead (& Rx_ID, RxTx_Data, & Rx_Data_Len, &
si ((Rx_ID == ID_2nd) && Msg_Rcvd) {
PORTB = RxTx_Data [0];
RxTx_Data [0] ++;
// incrementar datos recibidos
Delay_ms (10);
CANSPIWrite (ID_1st, RxTx_Data, 1, Can_Send_Flags);
}
}
}
Código para el segundo nodo CANSPI:


banderas
tx data buffer
de recepción
largo Rx_ID;
// Conexiones del módulo

void main () {
ANSEL = 0; // Configurar
ANSELH = 0;
C1ON_bit = 0; //
Desactivar comparadores
C2ON_bit = 0;
PORTB = 0; // borrar
PORTB
TRISB = 0; // establece
PORTB como salida
Can_Send_Flags = 0; // borrar
las banderas
Can_Send_Flags = _CANSPI_TX_PRIORITY_0 & // valor de

_CANSPI_TX_XTD_FRAME & // con
CANSPIWrite
Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE & // Valor de

_CANSPI_CONFIG_PHSEG2_PRG_ON & // con
CANSPIInit
SPI1_Init ();
// inicializar el módulo SPI1
CANSPIInitialize (1,3,3,3,1, Can_Init_Flags);
// inicializar el módulo
CANSPI externo CANSPISetOperationMode (_CANSPI_MODE_CONFIG, 0xFF);
// establece el modo CONFIGURACIÓN
CANSPISetMask (_CANSPI_MASK_B1, -1, _CANSPI_CONFIG_XTD_MSG);
// establece todos los bits de mask1 en unos
CANSPISetMask (_CANSPI_MASK_B2, -1, _CANSPI_CONFIG_XTD_MSG);
// establece todos los bits de mask2 a los
CANSPISetFilter (_CANSPI_FILTER_B2_F3, ID_1st, _CANSPI_CONFIG_XTD_MSG);
// establecer la id del filtro B2_F3 en el primer ID de nodo

// establece el modo NORMAL
while (1) {
Msg_Rcvd = CANSPIRead (& Rx_ID, RxTx_Data, & Rx_Data_Len, &
si ((Rx_ID == ID_1st) && Msg_Rcvd) {
// si el mensaje recibió la identificación de cheque
PORTB = RxTx_Data [0];
RxTx_Data [0] ++;
// incrementar los datos recibidos
CANSPIWrite (ID_2nd, RxTx_Data, 1, Can_Send_Flags);
}
}
}
Conexión HW
Ejemplo de interfaz del transceptor CAN MCP2510 con MCU a través de la interfaz SPI
Biblioteca Compact Flash
La biblioteca Compact Flash proporciona rutinas para acceder a los datos en la
tarjeta Compact Flash (abbr. CF más adelante en el texto). Las tarjetas CF son
elementos de memoria ampliamente utilizados, comúnmente utilizados con
cámaras digitales. La gran capacidad y el excelente tiempo de acceso de solo unos
pocos microsegundos los hacen muy atractivos para las aplicaciones de
microcontroladores.
En la tarjeta CF, los datos se dividen en sectores. Un sector suele comprender 512
bytes. Las rutinas para el manejo de archivos, las Cf_Fatrutinas, no se realizan
directamente sino sucesivamente a través del búfer 512B.
Importante:
 Las rutinas para el manejo de archivos solo pueden usarse con el
sistema de archivos FAT16.
 Las funciones de la biblioteca crean y leen archivos solo desde el
directorio raíz.
 Las funciones de biblioteca llenan las tablas FAT1 y FAT2 al escribir en
archivos, pero los datos del archivo se leen solo desde la tabla FAT1; es
decir, no hay recuperación si la tabla FAT1 se corrompe.
 Si la tarjeta MMC / SD tiene un registro de inicio maestro (MBR), la
biblioteca funcionará con la primera partición primaria (lógica)
disponible que tiene un tamaño distinto de cero. Si la tarjeta MMC / SD
tiene Volume Record Record (es decir, solo hay una partición lógica y
no MBR), la biblioteca funciona con la tarjeta completa como una sola
partición. Para obtener más información sobre MBR, unidades físicas y
lógicas, particiones primarias / secundarias y tablas de particiones,
consulte otros recursos, por ejemplo, Wikipedia y similares.
 Antes de la operación de escritura, asegúrese de no sobrescribir el
sector de arranque o FAT, ya que podría hacer que su tarjeta en una PC
o cámara digital sea ilegible. Las herramientas de mapeo de unidades,
como Winhex, pueden ser de gran ayuda.
Dependencias externas de Compact Flash Library

Las siguientes
variables deben
definirse en todos
Descripción
los proyectos Ejemplo:
:
utilizando la
biblioteca Compact
Flash:
Puerto de
extern sfr datos char CF_Data_Port at PORTD;
charCF_Data_Port; Compact
Flash.
extern sfr Línea de sbit CF_RDY atRB7_bit;
sbit CF_RDY; señal lista.
Escribir
extern sfr
sbit CF_WE; habilitar línea sbit CF_WE atLATB6_bit;
de señal.
Salida
extern sfr
sbit CF_OE; habilitar línea sbit CF_OE atLATB5_bit;
de señal.
Chip de
extern sfr detección de sbit CF_CD1 atRB4_bit;
sbit CF_CD1; línea de
señal.
Chip habilita
extern sfr
sbit CF_CE1; la línea de sbit CF_CE1 atLATB3_bit;
señal.
extern sfr Dirección pin sbit CF_A2 atLATB2_bit;
sbit CF_A2; 2.
sbit CF_A1; 1.
sbit CF_A0; 0.
extern sfr
sbitCF_RDY_direction Dirección del sbitCF_RDY_direction at TRISB7_bit
; pin Listo. ;
Dirección del
extern sfr
sbitCF_WE_direction; pin Habilitar sbitCF_WE_direction at TRISB6_bit;
escritura.
Dirección del
extern sfr pin de sbitCF_OE_direction at TRISB5_bit;
sbitCF_OE_direction; habilitación
de salida.
extern sfr Dirección del
sbitCF_CD1_direction at TRISB4_bit
sbitCF_CD1_direction pin Chip ;
; Detect.
sbitCF_CE1_direction at TRISB3_bit
sbitCF_CE1_direction pin chip ;
; habilitado.
Dirección del
extern sfr
sbitCF_A2_direction; pin Dirección sbitCF_A2_direction at TRISB2_bit;
2.
Dirección del
extern sfr
sbitCF_A1_direction; pin Dirección sbitCF_A1_direction at TRISB1_bit;
1.
Dirección de
extern sfr
sbitCF_A0_direction; la dirección 0 sbitCF_A0_direction at TRISB0_bit;
pin.
 Cf_Init
 Cf_Detect
 Cf_Enable
 Cf_Disable
 Cf_Read_Init
 Cf_Read_Byte
 Cf_Write_Init
 Cf_Write_Byte
 Cf_Read_Sector
 Cf_Write_Sector
Rutinas para el manejo de archivos:
 Cf_Fat_Init
 Cf_Fat_QuickFormat
 Cf_Fat_Assign
 Cf_Fat_Reset
 Cf_Fat_Read
 Cf_Fat_Rewrite
 Cf_Fat_Append
 Cf_Fat_Delete
 Cf_Fat_Write
 Cf_Fat_Set_File_Date
 Cf_Fat_Get_File_Date
 Cf_Fat_Get_File_Date_Modified
 Cf_Fat_Get_File_Size
 Cf_Fat_Get_Swap_File
La siguiente rutina es solo para uso interno por compilador:
 Cf_Issue_ID_Command
Cf_Init
Prototipo void Cf_Init ();
Devoluciones Nada.
Descripción Inicializa los puertos adecuadamente para la comunicación
con la tarjeta CF.
Requiere Variables globales :

 CF_Data_Port : Puerto de datos Compact Flash
 CF_RDY : Línea de señal lista
 CF_WE : Escribir habilitar línea de señal
 CF_OE : Línea de señal de habilitación de salida
 CF_CD1 : Chip de señal de detección de línea
 CF_CE1 : Habilitar línea de señal
 CF_A2 : Dirección pin 2
 CF_RDY_direction : Dirección del pin Ready

 CF_WE_direction : Dirección del pin
habilitación de escritura
 CF_OE_direction : Dirección del pin de
habilitación de salida
 CF_CD1_direction : Dirección del pin de
detección de viruta
 CF_CE1_direction : Dirección del pin de
habilitación del chip
 CF_A2_direction : Dirección del pin Dirección
2
1
0
Ejemplo // establecer Compact Flash pinout

carbón Cf_Data_Port en PORTD;
sbit CF_RDY en RB7_bit;

sbit CF_WE en LATB6_bit; // para escribir en el
pin de salida siempre use latch (familia
PIC18 ) sbit CF_OE en LATB5_bit; // para escribir
en el pin de salida siempre use latch (familia
PIC18 ) sbit CF_CD1 en RB4_bit;
sbit CF_CE1 en LATB3_bit; // para escribir en el
pin de salida siempre use latch (familia
PIC18 ) sbit CF_A2 en LATB2_bit; // para escribir
PIC18 ) sbit CF_A1 at LATB1_bit; // para escribir
PIC18 ) sbit CF_A0 en LATB0_bit; // para escribir
PIC18)
sbit CF_RDY_direction en TRISB7_bit;

sbit CF_WE_direction en TRISB6_bit;
sbit CF_OE_direction en TRISB5_bit;
sbit CF_CD1_direction en TRISB4_bit;
sbit CF_CE1_direction en TRISB3_bit;
sbit CF_A2_direction en TRISB2_bit;
// fin de cf pinout
...
Cf_Init (); // inicializar CF
Cf_Detect
Prototipo corto sin firma Cf_Detect ( void );
Devoluciones  1 - Si se detectó tarjeta CF

 0 de lo contrario
Descripción Comprueba la presencia de la tarjeta CF leyendo el chip

detectpin.
Requiere Los puertos MCU correspondientes deben inicializarse

adecuadamente para la tarjeta CF. Ver Cf_Init .
Ejemplo // Espere hasta que se inserte la tarjeta CF:

hacer
asm nop;
while (! Cf_Detect ());
Cf_Enable
Prototipo void Cf_Enable ( void );
Devoluciones Nada.
Descripción Habilita el dispositivo. Se debe llamar a la rutina solo si ha

deshabilitado el dispositivo por medio de
la rutina Cf_Dable . Estas dos rutinas en conjunto le
permiten liberar / ocupar la línea de datos cuando trabaja
con múltiples dispositivos.

Ejemplo // habilitar flash compacto

Cf_Enable ();
Cf_Disable
Prototipo void Cf_Disable ( void );
Devoluciones Nada.
Descripción La rutina desactiva el dispositivo y libera las líneas de

datos para otros dispositivos. Para volver a habilitar el
dispositivo, llame a Cf_Enable . Estas dos rutinas en
conjunto le permiten liberar / ocupar la línea de datos
cuando trabaja con múltiples dispositivos.
Ejemplo // deshabilitar flash compacto

Cf_Disable ();
Cf_Read_Init
Prototipo void Cf_Read_Init ( dirección larga
sin signo , sector_cuero corto sin firmar );
Devoluciones Nada.
Descripción Inicializa la tarjeta CF para lectura.

Parámetros:
 address: El primer sector en estar preparado
para la operación de lectura.
 sector_count: Número de sectores a ser
preparados para la operación de lectura.

Ejemplo // inicialice el flash compacto para leer desde el

sector 590
Cf_Read_Init (590, 1);
Cf_Read_Byte
Prototipo corto sin firmar Cf_Read_Byte ( void );
Devoluciones Devuelve un byte leído desde el búfer del sector Compact

Flash.
Nota:unsigned Se borra el byte más alto del valor de

retorno.
Descripción Lee un byte de la ubicación del búfer del sector Compact

Flash actualmente señalado por los punteros de lectura
internos. Estos punteros serán auto-escritos al leerlos.

La tarjeta CF debe estar inicializada para la operación de
lectura. Ver Cf_Read_Init .
Ejemplo // Leer un byte de Compact Flash:

Char Data;
...
datos = Cf_Read_Byte ();
Cf_Write_Init
Prototipo void Cf_Write_Init ( dirección larga
sin signo , sección corta sinsigno);
Devoluciones Nada.
Descripción Inicializa la tarjeta CF para escribir.

Parámetros:
 address: El primer sector en estar preparado
para la escritura.
 sectcnt: Número de sectores a preparar para
la escritura.

Ejemplo // inicialice el flash compacto para escribir en el

sector 590
Cf_Write_Init (590, 1);
Cf_Write_Byte
Prototipo void Cf_Write_Byte (datos cortos sin firmar);
Devoluciones Nada.
Descripción Escribe un byte en la ubicación del búfer del sector

Compact Flash actualmente señalado por la escritura de
punteros. Estos punteros serán auto-escritos al
leerlos. Cuando el búfer del sector está lleno, su contenido
se transferirá al sector de memoria flash correspondiente.
Parámetros:
 data_: byte para ser escrito.

La tarjeta CF debe estar inicializada para la operación de
escritura. Ver Cf_Write_Init .
Ejemplo datos de char_ = 0xAA;

...
Cf_Write_Byte (data_);
Cf_Read_Sector
Prototipo void Cf_Read_Sector ( unsigned
long sector_number, unsigned short * buffer);
Devoluciones Nada.
Descripción Lee un sector (512 bytes). Los datos de lectura se

almacenan en el búfer proporcionado por
el bufferparámetro.
Parámetros:
 sector_number: Sector a leer.
 buffer: Búfer de datos de al menos 512 bytes
de longitud.
Ejemplo // leer
datos cortos sin firmar del sector 22 [512];
...
Cf_Read_Sector (22, data);
Cf_Write_Sector
Prototipo void Cf_Write_Sector ( unsigned
long sector_number, unsigned short* buffer);
Devoluciones Nada.
Descripción Escribe 512 bytes de datos proporcionados por

el bufferparámetro en un sector de CF.
Parámetros:
 sector_number: Sector al que se escribirá.
 buffer: Búfer de datos de 512 bytes de
longitud.

Ejemplo // escribir al sector 22

datos cortos sin firmar [512];
...
Cf_Write_Sector (22, datos);
Cf_Fat_Init
Prototipo corto sin firma Cf_Fat_Init ();
Devoluciones  0 - Si la tarjeta CF se detectó y se inicializó con

éxito
 1 - si no se encontró el sector de arranque
FAT16
 255 - si la tarjeta no fue detectada
Descripción Inicializa la tarjeta CF, lee el sector de arranque CF FAT16

y extrae los datos necesarios que necesita la biblioteca.
Requiere Nada.
Ejemplo // Inicia la biblioteca FAT

si (! Cf_Fat_Init ()) {// Inicia la biblioteca FAT
...
}
Cf_Fat_QuickFormat
Prototipo unsigned char Cf_Fat_QuickFormat ( char *
cf_fat_label);
Devoluciones  0 - Si se detectó una tarjeta CF, se formateó
correctamente y se inicializó.
 1 - si el formato FAT16 no tuvo éxito
 255 - si la tarjeta no fue detectada
Descripción Formatos a FAT16 e inicializa la tarjeta CF.

Parámetros:
 cf_fat_label:Etiqueta de volumen (11
caracteres de longitud). Si se proporcionan
menos de 11 caracteres, la etiqueta se
rellenará con espacios. Si se pasa una cadena
nula, el volumen no se etiquetará.
Nota :
 Esta rutina se puede utilizar en su lugar o junto
con la rutina Cf_Fat_Init .
 Si la tarjeta CF ya contiene un sector de inicio
válido, permanecerá sin cambios (excepto el
campo de etiqueta de volumen) y solo se
borrarán las tablas FAT y ROOT. Además, se
establecerá la nueva etiqueta de volumen.
Requiere Nada.
Ejemplo // --- formatear e inicializar la biblioteca FAT -

if (! Cf_Fat_QuickFormat (& cf_fat_label)) {
...
}
Cf_Fat_Assign
Prototipo corto sin signo Cf_Fat_Assign ( char *
filename, charfile_cre_attr);
Devoluciones  0 Si el archivo no existe y no se crea ningún

archivo nuevo.
 1 si el archivo ya existe o el archivo no existe
pero se crea un nuevo archivo.
Descripción Asigna archivos para operaciones de archivos (leer,

escribir, eliminar ...). Todas las operaciones de archivo
subsiguientes se aplicarán sobre el archivo asignado.
Parámetros:
 filename:Nombre del archivo que debe
asignarse para las operaciones de archivo. El
nombre del archivo debe estar en formato DOS
8.3 (nombre_archivo.extensión). El nombre y
la extensión del archivo serán rellenados
automáticamente con espacios por la biblioteca
si tienen menos de la longitud requerida (es
decir, "mikro.tx" -> "mikro .tx"), por lo que el
usuario no tiene que ocuparse de eso. El
nombre del archivo y la extensión no
distinguen entre mayúsculas y minúsculas. La
biblioteca los convertirá automáticamente en
un caso adecuado, de modo que el usuario no
tiene que ocuparse de eso.
Además, para mantener la compatibilidad con
la versión anterior de esta biblioteca, los
nombres de los archivos se pueden ingresar
como una cadena MAYÚSCULAS de 11 bytes de
longitud sin caracteres de punto entre el
nombre del archivo y la extensión (es decir,
"MIKROELETXT" -> MIKROELE.TXT) . En este
caso, los últimos 3 caracteres de la cadena se
consideran una extensión de archivo.
 file_cre_attr: Creación de archivos y
distintivos de atributos. Cada bit corresponde al
atributo apropiado del archivo:
Poco Máscara Descripción
0 0x01 Solo lectura
1 0x02 Oculto
2 0x04 Sistema
3 0x08 Etiqueta de volumen
4 0x10 Subdirectorio
5 0x20 Archivo
Dispositivo (solo uso interno,

6 0x40
nunca encontrado en el disco)
Bandera de creación de archivo. Si

el archivo no existe y se establece
7 0x80 este indicador, se creará un nuevo
archivo con el nombre
especificado.
Nota: los nombres de archivo largos

(LFN) no son compatibles.
Requiere La tarjeta CF y la biblioteca CF deben inicializarse para las

operaciones de archivo. Ver Cf_Fat_Init .
Ejemplo // crear archivo con atributos de archivo si no

existe ya
Cf_Fat_Assign ("MIKRO007.TXT", 0xA0);
Cf_Fat_Reset
Prototipo void Cf_Fat_Reset ( unsigned long * size);
Devoluciones Nada.
Descripción Abre el archivo actualmente asignado para su lectura.
Parámetros:
 size:búfer para almacenar el tamaño del
archivo a. Después de que el archivo se haya
abierto para leer, su tamaño se devuelve a
través de este parámetro.

El archivo debe ser asignado
previamente. Ver Cf_Fat_Assign .
Ejemplo tamaño largo sin firmar ;

...
Cf_Fat_Reset (tamaño);
Cf_Fat_Read
Prototipo void Cf_Fat_Read ( short * bdata sin signo);
Devoluciones Nada.
Descripción Lee un byte del archivo asignado actualmente abierto para

leer. Tras la ejecución de la función, los punteros del
archivo se establecerán en el siguiente carácter del
archivo.
Parámetros:
 bdata:búfer para almacenar el byte de lectura
a. A través de este parámetro, se devuelve el
byte de lectura de esta función.

El archivo debe estar abierto para su
lectura. Ver Cf_Fat_Reset .
Ejemplo personaje char

...
Cf_Fat_Read (& carácter);
Cf_Fat_Rewrite
Prototipo void Cf_Fat_Rewrite ();
Devoluciones Nada.
Descripción Abre el archivo actualmente asignado para la escritura. Si

el archivo no está vacío, su contenido será borrado.

Ejemplo // abrir archivo para escribir

Cf_Fat_Rewrite ();
Cf_Fat_Append
Prototipo void Cf_Fat_Append ();
Devoluciones Nada.
Descripción Abre el archivo asignado actualmente para anexar. Sobre

esta función, los punteros del archivo de ejecución se
colocarán después del último byte en el archivo, por lo que
cualquier operación posterior de escritura del archivo
comenzará desde allí.

Ejemplo // abrir archivo para

agregar Cf_Fat_Append ();
Cf_Fat_Delete
Prototipo void Cf_Fat_Delete ();
Devoluciones Nada.
Descripción Borra el archivo actualmente asignado de la tarjeta CF.

Ejemplo // borrar el archivo actual

Cf_Fat_Delete ();
Cf_Fat_Write
Prototipo void Cf_Fat_Write ( char *
fdata, unsigned data_len);
Devoluciones Nada.
Descripción Escribe el número solicitado de bytes en el archivo

asignado actualmente abierto para escritura.
Parámetros:
 fdata: Datos a escribir.
 data_len: Número de bytes a escribir.
El archivo debe estar abierto para
escritura. Consulte Cf_Fat_Rewrite o Cf_Fat_Append .
Ejemplo char file_contents [42];

...
Cf_Fat_Write (file_contents, 42); // escribir datos
en el archivo asignado
Cf_Fat_Set_File_Date
Prototipo void Cf_Fat_Set_File_Date ( unsigned
int year, unsigned shortmonth, unsigned
short day, unsigned short hours, unsigned
shortminute, unsigned short seconds);
Devoluciones Nada.
Descripción Establece el sello de fecha / hora. Cualquier operación

subsiguiente de escritura de archivos escribirá este sello en
los atributos de hora / fecha del archivo asignado
actualmente.
Parámetros:
 year:año atributo Valores válidos: 1980-2107.
 month:atributo del mes. Valores válidos: 1-12
 day:atributo del día. Valores válidos: 1-31
 hours:Atributo de horas. Valores válidos: 0-23
 mins:atributo de minutos. Valores válidos: 0-
59.
 seconds:atributo de segundos Valores válidos:
0-59.

escritura. Consulte Cf_Fat_Rewrite o Cf_Fat_Append .
Ejemplo Cf_Fat_Set_File_Date (2005,9,30,17,41,0);
Cf_Fat_Get_File_Date
Prototipo void Cf_Fat_Get_File_Date ( unsigned int *
year, unsigned short * month, unsigned short *
day, unsigned short * hours, unsigned short*
mins);
Devoluciones Nada.
Descripción Lee los atributos de hora / fecha del archivo asignado

actualmente.
Parámetros:
 year:buffer para almacenar el atributo del año
a. Al ejecutarse la función, el atributo año se
devuelve a través de este parámetro.
 month:buffer para almacenar el atributo del
mes a. A la ejecución de la función, el atributo
del mes se devuelve a través de este
parámetro.
 day:buffer para almacenar el atributo del día
a. A la ejecución de la función, el atributo día
se devuelve a través de este parámetro.
 hours:búfer para almacenar las horas
atribuidas a. A la ejecución de la función, el
atributo horas se devuelve a través de este
parámetro.
 mins:buffer para almacenar el atributo de
minutos a. A la ejecución de la función, el
atributo de minutos se devuelve a través de
este parámetro.

Ejemplo año
sin firmar char mes, día, horas, minutos;
...
Cf_Fat_Get_File_Date (& year, & month, & day, &
hours, & mins);
Cf_Fat_Get_File_Date_Modified
Prototipo void Cf_Fat_Get_File_Date_Modified ( unsigned
int * year, unsigned short * month, unsigned
short * day, unsigned short * hours, unsigned
short * mins);
Devoluciones Nada.
Descripción Recupera la fecha / hora de la última modificación del

archivo asignado actualmente.
Parámetros:
 year:buffer para almacenar el año de
modificación del atributo a. Tras la ejecución de
la función, el atributo de modificación se
 month:buffer para almacenar el mes del
atributo de modificación a. Tras la ejecución de
la función, el mes de modificación del atributo
 day:buffer para almacenar el día del atributo
de modificación a. Tras la ejecución de la
función, el atributo de modificación se devuelve
a través de este parámetro.
 hours:buffer para almacenar horas de
la función, se devuelve el atributo de
modificación a través de este parámetro.
 mins:buffer para almacenar minutos de
la función, el atributo de modificación de
minutos se devuelve a través de este
parámetro.

Ejemplo año
sin firmar char mes, día, horas, minutos;
...
Cf_Fat_Get_File_Date_Modified (& year, & month, &
day, & hours, & mins);
Cf_Fat_Get_File_Size
Prototipo sin signo largo Cf_Fat_Get_File_Size ();
Devoluciones Tamaño del archivo actualmente asignado en bytes.
Descripción Esta función lee el tamaño del archivo actualmente

asignado en bytes.

Ejemplo unsigned long my_file_size;

...
my_file_size = Cf_Fat_Get_File_Size ();
Cf_Fat_Get_Swap_File
Prototipo unsigned long Cf_Fat_Get_Swap_File ( unsigned
long sectores_cnt, char *
filename, char file_attr);
Devoluciones  Número del sector de inicio para el archivo de

intercambio recién creado, si había suficiente
espacio libre en la tarjeta CF para crear el
archivo del tamaño requerido.
Descripción Esta función se utiliza para crear un archivo de intercambio

de nombre y tamaño predefinidos en el medio CF. Si ya
existe un archivo con el nombre especificado en el medio,
la búsqueda de sectores consecutivos ignorará los sectores
ocupados por este archivo. Por lo tanto, se recomienda
borrar dicho archivo si existe antes de llamar a esta
función. Si no se borra y todavía hay espacio suficiente
para un nuevo archivo de intercambio, esta función lo
eliminará después de asignar un nuevo espacio de
memoria para un nuevo archivo de intercambio.
El propósito del archivo de intercambio es hacer que la
lectura y la escritura en el medio de CF sea lo más rápida
posible, utilizando las funciones Cf_Read_Sector
() y Cf_Write_Sector () directamente, sin dañar el sistema
FAT. El archivo de intercambio se puede considerar como
una "ventana" en el medio donde el usuario puede escribir
/ leer datos libremente. Su propósito principal en la
biblioteca de mikroC es ser usado para la adquisición
rápida de datos; cuando la adquisición crítica de tiempo ha
finalizado, los datos pueden reescribirse en un archivo
"normal" y formatearse de la manera más adecuada.
Parámetros:
 sectors_cnt: número de sectores consecutivos
que el usuario desea que tenga el archivo de
intercambio.
8.3 (nombre_archivo.extensión). El nombre y
la extensión del archivo serán rellenados
Además, para mantener la compatibilidad con
la versión anterior de esta biblioteca, los
nombres de los archivos se pueden ingresar
como una cadena MAYÚSCULAS de 11 bytes de
nombre del archivo y la extensión (es decir,
"MIKROELETXT" -> MIKROELE.TXT) . En este
 file_attr:Creación de archivos y distintivos de
atributos. Cada bit corresponde al atributo
apropiado del archivo:
0 0x01 Solo lectura
1 0x02 Oculto
2 0x04 Sistema
5 0x20 Archivo

6 0x40
7 0x80 No utilizado


Ejemplo // -------------- Intente crear un archivo de

intercambio con atributo de archivo, cuyo tamaño
será de al menos 1000 sectores.
// Si tiene éxito, envía el No. de sector de inicio
sobre UART de
tamaño largo sin firmar ;
...
size = Cf_Fat_Get_Swap_File (1000, "mikroE.txt",
0x20);
si (tamaño) {
UART1_Write (0xAA);
UART1_Write (Lo (tamaño));
UART1_Write (Hola (tamaño));
UART1_Write (Mayor (tamaño));
UART1_Write (el más alto (tamaño));
UART1_Write (0xAA);
}
Este ejemplo consta de varios bloques que demuestran diversos aspectos del uso
de la biblioteca Cf_Fat16. Estos son:
 Creación de nuevo archivo y escritura en él;
 Abrir el archivo existente y volver a escribirlo (escribir desde el inicio
del archivo);
 Abrir el archivo existente y agregarle datos (escritura desde el final del
archivo);
 Abrir un archivo y leer datos desde él (enviarlo al terminal USART);
 Creando y modificando varios archivos a la vez;
 Lectura de contenidos de archivo;
 Eliminar archivo (s);
 Creación del archivo de intercambio (ver Ayuda para más detalles);
// establecer Compact Flash pinout

carbón Cf_Data_Port en PORTD;
sbit CF_RDY en RB7_bit;

sbit CF_WE en LATB6_bit; // para escribir en el pin de salida siempre
use latch (familia
PIC18 ) sbit CF_OE en LATB5_bit; // para escribir en el pin de salida
siempre use latch (familia
PIC18 ) sbit CF_CD1 en RB4_bit;
sbit CF_CE1 en LATB3_bit; // para escribir en el pin de salida siempre
use latch (familia
PIC18 ) sbit CF_A2 en LATB2_bit; // para escribir en el pin de salida
PIC18 ) sbit CF_A1 at LATB1_bit; // para escribir en el pin de salida
PIC18 ) sbit CF_A0 en LATB0_bit; // para escribir en el pin de salida
siempre use latch (familia PIC18)
sbit CF_RDY_direction en TRISB7_bit;

sbit CF_WE_direction en TRISB6_bit;
sbit CF_OE_direction en TRISB5_bit;
sbit CF_CD1_direction en TRISB4_bit;
sbit CF_CE1_direction en TRISB3_bit;
// fin de cf pinout
const LINE_LEN = 39;

char err_txt [20] = "FAT16 no encontrado";
char file_contents [LINE_LEN] = "XX CF FAT16 library de Anton Rieckertn";
char filename [14] = "MIKRO00x.TXT"; // Nombres de
archivos
sin firmar en bucle corto , loop2;
sin firmar largo i, tamaño;
búfer de char [512];
// UART1 escribe texto y nueva línea (retorno de carro +

salto de línea) void UART1_Write_Line ( char * uart_text) {
UART1_Write_Text (uart_text);
UART1_Write (13);
UART1_Write (10);
}
// Crea un nuevo archivo y escribe algunos datos en él

vacío M_Create_New_File () {
nombre de archivo [7] = 'A';
Cf_Fat_Set_File_Date (2005,6,21,10,35,0); // Establecer información de
fecha y hora del archivo
Cf_Fat_Assign (& filename, 0xA0); // Encuentra el archivo existente
o crea uno nuevo
Cf_Fat_Rewrite (); // Para borrar el archivo y
comenzar con nuevos datos
para (loop = 1; loop <= 99; loop ++) {
UART1_Write ('.');
file_contents [0] = loop / 10 + 48;
file_contents [1] = loop% 10 + 48;
Cf_Fat_Write (file_contents, LINE_LEN-1); // escribir datos en el
archivo asignado
}
}
// Crea muchos archivos nuevos y escribe datos en ellos

void M_Create_Multiple_Files () {
for (loop2 = 'B'; loop2 <= 'Z'; loop2 ++) {
UART1_Write (loop2); // señalizar el
nombre del archivo de progreso [7] = loop2; //
establecer nombre de archivo
Cf_Fat_Set_File_Date (2005,6,21,10,35,0); // Establecer información de
fecha y hora del archivo
Cf_Fat_Assign (& filename, 0xA0); // encuentra el archivo
existente o crea uno nuevo
Cf_Fat_Rewrite (); // Para borrar el archivo y
archivo asignado
}
}
}
// Abre un archivo existente y lo vuelve a escribir

void M_Open_File_Rewrite () {
nombre de archivo [7] = 'C';
Cf_Fat_Assign (& filename, 0);
Cf_Fat_Rewrite ();
archivo asignado
}
}
// Abre un archivo existente y le agrega datos

// (y altera la marca de fecha / hora)
void M_Open_File_Append () {
nombre de archivo [7] = 'B';
Cf_Fat_Set_File_Date (2009, 1, 23, 17, 22, 0);
Cf_Fat_Append (); // Preparar
archivo para agregar
Cf_Fat_Write (" para mikroElektronika 2010n", 27); // Escribir datos
}
// Abre un archivo existente, lee los datos y lo coloca en UART

void M_Open_File_Read () {
char character;

Cf_Fat_Reset (& size); // Para leer el archivo, el
procedimiento devuelve el tamaño del archivo
para (i = 1; i <= tamaño; i ++) {
Cf_Fat_Read (& carácter);
UART1_Write (carácter); // Escribir datos en UART
}
}
// Borra un archivo. Si el archivo no existe, primero se creará

// y luego borrado.
void M_Delete_File () {
nombre de archivo [7] = 'F';
Cf_Fat_Assign (nombre de archivo, 0);
Cf_Fat_Delete ();
}
// Comprueba si el archivo existe, y si es así envía su fecha de creación

// y tamaño de archivo a través de UART
void M_Test_File_Exist () {
unsigned long fsize;
unsigned int año;
mes corto sin firmar , día, hora, minuto;
sin firma char outstr [12];
nombre de archivo [7] = 'B'; // descomentar esta línea para buscar

el archivo que SÍ existe
// nombre de archivo [7] = 'F'; // elimine el comentario de esta línea
para buscar el archivo que NO existe
si (Cf_Fat_Assign (nombre de archivo, 0)) {
// --- se ha encontrado el archivo - obtenga su fecha
Cf_Fat_Get_File_Date (& year, & month, & day, & hour, & minute);
UART1_Write_Text ("created:");
WordToStr (año, outstr);
UART1_Write_Text (outstr);
ByteToStr (month, outstr);
WordToStr (día, outstr);
WordToStr (hora, outstr);
WordToStr (minuto, outstr);
// --- se ha encontrado el archivo - obtener su fecha de modificación

Cf_Fat_Get_File_Date_Modified (& year, & month, & day, & hour, &
minute);
UART1_Write_Text ("modificado:");
// --- obtener el tamaño del archivo

fsize = Cf_Fat_Get_File_Size ();
LongToStr (( firmado largo ) fsize, outstr);
UART1_Write_Line (outstr);
}
else {
// --- no se encontró el archivo - señalalo
UART1_Write (0x55);
Delay_ms (1000);
UART1_Write (0x55);
}
}
// Intenta crear un archivo de intercambio, cuyo tamaño será de al menos

100
// sectores (consulte la Ayuda para obtener más información)
void M_Create_Swap_File () {
unsigned int i;
para (i = 0; i <512; i ++)

Tampón [i] = i;
size = Cf_Fat_Get_Swap_File (5000, "mikroE.txt", 0x20); // vea la
ayuda en esta función para más detalles
si (tamaño) {
LongToStr (( firmado largo ) tamaño, err_txt);
UART1_Write_Line (err_txt);
para (i = 0; i <5000; i ++) {

Cf_Write_Sector (size ++, Buffer);
UART1_Write ('.');
}
}
}
// Principal. Descomente las funciones para probar la (s) operación (es)

deseada (s)
void main () {
#define COMPLETE_EXAMPLE // comente esta línea para simplificar
/
reducir el ejemplo ADCON1 | = 0x0F; // Configurar los
pines AN como
CMCON digital = = 7; // apagar los comparadores
// Inicializar módulo UART1

UART1_Init (19200);
Delay_ms (10);
UART1_Write_Line ("PIC-Started"); // presente informe PIC
// use el formato rápido fat16 en lugar de la rutina init si se necesita

un formato
si (Cf_Fat_Init () == 0) {
Delay_ms (2000); // espere un momento hasta que la
tarjeta se estabilice
// el período depende de la tarjeta CF
usada
// --- Inicio de prueba
UART1_Write_Line ("Test Start.");
// --- Rutinas de prueba. Descoméntelos uno por uno para probar
ciertas características
M_Create_New_File ();
#ifdef COMPLETE_EXAMPLE
M_Create_Multiple_Files ();
M_Open_File_Rewrite ();
M_Open_File_Append ();
M_Open_File_Read ();
M_Delete_File ();
M_Test_File_Exist ();
M_Create_Swap_File ();
#terminara si
UART1_Write_Line ("Test End.");
}
else {
UART1_Write_Line (err_txt); // Nota: Cf_Fat_Init intenta inicializar
una tarjeta más de una vez.
// Si la tarjeta no está presente, la
inicialización puede durar más (dependiendo de la velocidad del reloj)
}
Conexión HW
Diagrama de pin de la tarjeta de memoria CF
Biblioteca EEPROM
La memoria de datos EEPROM está disponible con una serie de MCU PIC. mikroC
PRO para PIC incluye una biblioteca para un trabajo cómodo con EEPROM .
 EEPROM_Leer
 EEPROM_Write
EEPROM_Leer
Prototipo // para PIC16 EEPROM_Read
corto sin firmar ( dirección corta sin signo );
// para PIC18
sin firma EEPROM_Read ( dirección int sin
firmar );
Devoluciones Devuelve el byte de la dirección especificada.
Descripción Lee datade lo especificado address. El

parámetro addresses dependiente de MCU; para la familia
PIC16 es de tipo corto, y para la familia PIC18 es de tipo
entero.
Requiere Requiere módulo EEPROM .

Asegurar un mínimo de 20 ms de retraso entre el uso
sucesivo de rutinas EEPROM_Writey EEPROM_Read. Aunque
PIC escribirá el valor correcto, EEPROM_Readpuede devolver
un resultado indefinido.
Ejemplo toma corta sin firmar ;

...
take = EEPROM_Read (0x3F);
EEPROM_Write
Prototipo // para PIC16
void EEPROM_Write ( dirección corta
sin firmar , datos cortos sin firmar );
// para PIC18
void EEPROM_Write ( dirección int
sin firmar , datos cortos sin firmar );
Devoluciones Nada.
Descripción Escribe dataa los especificados address. El

parámetro addresses dependiente de MCU; para la familia
PIC16 es de tipo corto, y para la familia PIC18 es de tipo
entero.
Tenga en cuenta que todas las interrupciones se
desactivarán durante la ejecución de la EEPROM_Writerutina
(se borrará el bit GIE del registro INTCON). La rutina
restaurará el estado anterior de este bit en la salida.
Requiere Requiere módulo EEPROM .

Asegurar un mínimo de 20 ms de retraso entre el uso
sucesivo de rutinas EEPROM_Writey EEPROM_Read. Aunque
PIC escribirá el valor correcto, EEPROM_Readpuede devolver
un resultado indefinido.
Ejemplo EEPROM_Write (0x32, 19);
El ejemplo demuestra el uso de la biblioteca EEPROM .
char ii; // variable de bucle
void main () {
ANSEL = 0; // Configurar pines AN como E / S
digital
ANSELH = 0;
C2ON_bit = 0;
PORTB = 0;
PORTC = 0;
PORTD = 0;
TRISB = 0;
TRISC = 0;
TRISD = 0;
para (ii = 0; ii <32; ii ++) // Rellenar el búfer de datos

EEPROM_Write (0x80 + ii, ii); // Escribe los datos en la
dirección 0x80 + ii
EEPROM_Write (0x02,0xAA); // Escriba algunos datos en la

dirección 2
EEPROM_Write (0x50,0x55); // Escribe algunos datos en la
dirección 0150
Delay_ms (1000); // Parpadeo de los indicadores

PORTB y PORTC
PORTB = 0xFF; // para indicar inicio de lectura
PORTC = 0xFF;
Delay_ms (1000);
PORTB = 0x00;
PORTC = 0x00;
Delay_ms (1000);
PORTB = EEPROM_Read (0x02); // Leer los datos de la

dirección 2 y mostrarlos en PORTB
PORTC = EEPROM_Read (0x50); // Leer los datos de la
dirección 0x50 y mostrarlos en PORTC
Delay_ms (1000);
para (ii = 0; ii <32; ii ++) { // Leer el bloque de 32 bytes

de la dirección 0x80
PORTD = EEPROM_Read (0x80 + ii); // y mostrar datos en PORTD
Delay_ms (250);
}
}
Epson S1D13700 Graphic Lcd Library

El mikroC PRO para PIC proporciona una biblioteca para trabajar con Glcds basado
en el controlador Epson S1D13700.
El S1D13700 Glcd es capaz de mostrar texto y gráficos en un panel LCD. El
S1D13700 Glcd permite gráficos y texto en capas, el desplazamiento de la pantalla
en cualquier dirección y la partición de la pantalla en varias pantallas.
Incluye 32K bytes de memoria de visualización SRAM incorporada que se utiliza
para almacenar texto, códigos de caracteres y gráficos de mapa de bits.
El S1D13700 Glcd maneja funciones de controlador de pantalla que incluyen:
 Transferencia de datos desde el microprocesador de control a la
memoria intermedia
 Lectura de datos de la memoria, conversión de datos para mostrar
píxeles
 Generando señales de temporización para el panel LCD
El S1D13700 Glcd está diseñado con un generador de caracteres interno que
admite 160 caracteres de 5x7 píxeles en la ROM interna de máscara (CGROM) y 64
caracteres de 8x8 píxeles en el generador de caracteres RAM (CGRAM).
Cuando no se usa el CGROM, se admiten hasta 256 caracteres de 8x16 píxeles en
CGRAM.
Dependencias externas de la Epson S1D13700 Graphic Lcd Library
Las siguientes
variables deben
definirse en todos los Descripci
Ejemplo:
proyectos utilizando la ón:
biblioteca de gráficos
Lcd S1D13700:
Bus de
extern sfr
charS1D13700_DATA; datos del char S1D13700_DATA atPORTD;
sistema.
extern sfr Escribir sbit S1D13700_WR atLATC2_bit;
sbitS1D13700_WR; señal.
extern sfr Leer la sbit S1D13700_RD atLATC1_bit;
sbitS1D13700_RD; señal.
Dirección
extern sfr
sbitS1D13700_A0; del sistema sbit S1D13700_A0 atLATC0_bit;
pin.
extern sfr Restablece sbit S1D13700_RES atLATC4_bit;
sbitS1D13700_RES; r la señal.
extern sfr Selección sbit S1D13700_CS atLATC4_bit;
sbitS1D13700_CS; de chip.
Dirección
de los
extern sfr
sbitS1D13700_DATA_Direc pines del sbitS1D13700_DATA_Direction at TRI
tion; bus de SD;
datos del
sistema.

sbitS1D13700_WR_Direction at TRISC
sbitS1D13700_WR_Directi del pin de 2_bit;
on; escritura.
sbitS1D13700_RD_Direction at TRISC
sbitS1D13700_RD_Directi del pin de 1_bit;
on; lectura.
Dirección
extern sfr del pin de
sbitS1D13700_A0_Direction at TRISC
sbitS1D13700_A0_Directi dirección 2_bit;
on; del
sistema.

sbitS1D13700_RES_Direction at TRIS
sbitS1D13700_RES_Direct del pin de C0_bit;
ion; reinicio.
extern sfr
sbitS1D13700_CS_Directi Dirección sbitS1D13700_CS_Direction at TRISC
on; del pin de 4_bit;
selección
de chip.
 S1D13700_Init
 S1D13700_Write_Command
 S1D13700_Write_Parameter
 S1D13700_Read_Parameter
 S1D13700_Fill
 S1D13700_GrFill
 S1D13700_TxtFill
 S1D13700_Display_GrLayer
 S1D13700_Display_TxtLayer
 S1D13700_Set_Cursor
 S1D13700_Display_Cursor
 S1D13700_Write_Char
 S1D13700_Write_Text
 S1D13700_Dot
 S1D13700_Line
 S1D13700_H_Line
 S1D13700_V_Line
 S1D13700_Rectangle
 S1D13700_Box
 S1D13700_Rectangle_Round_Edges
 S1D13700_Rectangle_Round_Edges_Fill
 S1D13700_Circulo
 S1D13700_Circle_Fill
 S1D13700_Imagen
 S1D13700_Imagen parcial
S1D13700_Init
Prototipo void S1D13700_Init ( ancho int
sin signo , alto char sin signo );
Devoluciones Nada.
Descripción Inicializa S1D13700 Graphic Lcd controller.

Parámetros:
 width: Ancho del panel glcd.
 height: Altura del panel glcd.

 S1D13700_Data_Port: Puerto de bus de datos.
 S1D13700_WR: Escribir pin de señal.
 S1D13700_RD: Leer pin de señal.
 S1D13700_A0: Comando / señal de señal de
datos.
 S1D13700_RES: Restablecer pin de señal.
 S1D13700_CS: Chip de señal de selección de
pin.
 S1D13700_Data_Port_Direction: Dirección del

puerto del bus de datos.
 S1D13700_WR_Direction: Dirección de la señal
de escritura del pin.
 S1D13700_RD_Direction: Dirección del pin de
señal de lectura.
 S1D13700_A0_Direction: Dirección de señal de
comando / datos pin.
 S1D13700_RES_Direction: Dirección del pin de
señal de reinicio.
 S1D13700_CS_Direction: Dirección del pin de
señal Chip Select.
Ejemplo // Conexiones del módulo S1D13700

char S1D13700_Data_Port en PORTD;
sbit S1D13700_WR en LATC2_bit;
sbit S1D13700_RD en LATC1_bit;
sbit S1D13700_A0 en LATC0_bit;
sbit S1D13700_RES en LATC4_bit;
sbit S1D13700_CS en LATC5_bit;
char S1D13700_Data_Port_Direction en TRISD;

sbit S1D13700_WR_Direction at TRISC2_bit;
sbit S1D13700_RD_Direction at TRISC1_bit;
sbit S1D13700_A0_Dirección en TRISC0_bit;
sbit S1D13700_RES_Direction at TRISC4_bit;
sbit S1D13700_CS_Direction at TRISC5_bit;
// Fin de las conexiones del módulo S1D13700.
...
// pantalla inicial para 320 píxeles de ancho, 240
píxeles de altura
S1D13700_Init (320, 240);
S1D13700_Write_Command
Prototipo void S1D13700_Write_Command ( comando char );
Devoluciones Nada.
Descripción Escribe un comando al controlador S1D13700.

Parámetros:
 command: Mandato a emitir:
Valor Descripción
S1D13700_SYSTEM_SET Ajustes generales del sistema.
Entrar en modo de ahorro de

S1D13700_POWER_SAVE energía.
S1D13700_DISP_ON Encienda la pantalla.
S1D13700_DISP_OFF Apague la pantalla.
Configuración de texto y
S1D13700_SCROLL gráficos de las regiones de
dirección.
El cursor se mueve justo
S1D13700_CS_RIGHT después de escribir en la
memoria de visualización.
El cursor se mueve a la
S1D13700_CS_LEFT izquierda después de escribir en
la memoria de visualización.
El cursor se mueve hacia arriba

S1D13700_CS_UP después de escribir en la
El cursor se mueve hacia abajo

S1D13700_CS_DOWN después de escribir en la
Configurar cómo se
S1D13700_OVLAY superponen las capas.
Configurar la dirección RAM

S1D13700_CGRAM_ADR del generador de caracteres.
Establecer velocidad de
S1D13700_HDOT_SCR desplazamiento horizontal.
Establecer la dirección del

S1D13700_CSRW cursor.
S1D13700_CSRR Lea la dirección del cursor.
Selecciona la profundidad de la
S1D13700_GRAYSCALE escala de grises, en bits por
píxel (bpp).
Escribir para mostrar la

S1D13700_MEMWRITE memoria.
Leer de la memoria de la
S1D13700_MEMREAD pantalla.
Requiere El módulo Glcd necesita ser inicializado. Ver

la rutina S1D13700_Init .
Ejemplo // Encienda la pantalla en

S1D13700_Write_Command (S1D13700_DISP_ON);
S1D13700_Write_Parameter
Prototipo void S1D13700_Write_Parameter ( parámetro char );
Devoluciones Nada.
Descripción Escribe un parámetro en el controlador S1D13700.

Parámetros:
 parameter: parámetro a escribir.
Anteriormente, un comando debe enviarse a través de
la rutina S1D13700_Write_Command .
Ejemplo S1D13700_Write_Command (S1D13700_CSRW); //

establecer la dirección del cursor
S1D13700_Write_Parameter (Lo (inicio)); // enviar
byte inferior de la dirección del cursor
S1D13700_Write_Parameter (Hola (inicio)); // enviar
dirección de cursor de byte superior
S1D13700_Read_Parameter
Prototipo char S1D13700_Read_Parameter ();
Devoluciones Nada.
Descripción Lee un parámetro desde el puerto GLCD.

Ejemplo parámetro = S1D13700_Read_Parameter ();
S1D13700_Fill
Prototipo void S1D13700_Fill ( char d, unsigned
int start, unsigned int len);
Devoluciones Nada.
Descripción Rellena el bloque de memoria Glcd con un byte dado.

Parámetros:
 d: byte para ser escrito.
 start: Dirección de inicio del bloque de
memoria.
 len: Longitud del bloque de memoria en bytes.

Ejemplo // desde la dirección de inicio de 0x3000, complete

el tamaño de bloque de memoria de 0x7FFF con 0x20
S1D13700_Fill (0x20, 0x3000, 0x7FFF);
S1D13700_GrFill
Prototipo void S1D13700_GrFill ( char d);
Devoluciones Nada.
Descripción Rellene la capa gráfica con el valor apropiado (0 para
borrar).
Parámetros:
 d: Valor para rellenar la capa gráfica con.

Ejemplo // borrar el panel gráfico actual

S1D13700_GrFill (0);
S1D13700_TxtFill
Prototipo void S1D13700_TxtFill ( char d);
Devoluciones Nada.
Descripción Rellene el panel de texto actual con el valor apropiado (0

para borrar).
Parámetros:
 d: Este valor se utilizará para rellenar el panel
de texto.

Ejemplo // borrar el panel de texto actual

S1D13700_TxtFill (0);
S1D13700_Display_GrLayer
Prototipo void S1D13700_Display_GrLayer ( modo char );
Devoluciones Nada.
Descripción Mostrar la capa gráfica seleccionada.

Parámetros:
 mode:Modo de capa gráfica. Valores válidos:
Valor Descripción
Desactivar la capa
S1D13700_LAYER_OFF gráfica.
Encienda la capa
S1D13700_LAYER_ON gráfica.
Encienda la capa
gráfica y flashéela a
S1D13700_LAYER_FLASH_2Hz una velocidad de 2
Hz.
Encienda la capa
S1D13700_LAYER_FLASH_16Hz gráfica y flashéela a
una velocidad de 16
Hz.

Ejemplo // Encender capa gráfica

S1D13700_Display_GrLayer (S1D13700_LAYER_ON);
S1D13700_Display_TxtLayer
Prototipo void S1D13700_Display_TxtLayer ( modo char );
Devoluciones Nada.
Descripción Mostrar la capa de texto seleccionada.

Parámetros:
 mode:Modo de capa de texto. Valores válidos:
Valor Descripción
Desactivar la capa
S1D13700_LAYER_OFF gráfica.
Encienda la capa
S1D13700_LAYER_ON gráfica.
Encienda la capa
Hz.
Encienda la capa
Hz.

Ejemplo // Mostrar en la capa de texto

S1D13700_Display_TxtLayer (S1D13700_LAYER_ON);
S1D13700_Set_Cursor
Prototipo anular S1D13700_Set_Cursor
( Char anchura, Char altura, Char modo);
Devoluciones Nada.
Descripción Establece las propiedades del cursor.

Parámetros:
 width: en píxeles-1 (debe ser menor o igual
que el tamaño de carácter horizontal).
 height: en las líneas-1 (debe ser menor o igual
que el tamaño de carácter vertical).
 mode:modo cursor Valores válidos:
Valor Descripción
Establecer la forma
S1D13700_CURSOR_UNDERSCORE del cursor -
subrayado.
Establecer la forma
S1D13700_CURSOR_BLOCK del cursor - bloque.

Ejemplo // establece el cursor con las siguientes

propiedades: ancho 5px, alto 10px, forma del cursor
- bloque
S1D13700_Set_Cursor (5, 10, S1D13700_CURSOR_BLOCK);
S1D13700_Display_Cursor
Prototipo void S1D13700_Display_Cursor ( modo char );
Devoluciones Nada.
Descripción Muestra el cursor.

Parámetros:
 mode:parámetro de modo Valores válidos:
Valor Descripción
Desactivar la capa
S1D13700_CURSOR_OFF gráfica.
Encienda la capa
S1D13700_CURSOR_ON gráfica.
Encienda la capa
gráfica y flashéela
S1D13700_CURSOR_FLASH_2Hz a una velocidad de
2 Hz.
Encienda la capa
gráfica y flashéela
S1D13700_CURSOR_FLASH_16Hz a una velocidad de
16 Hz.

Ejemplo // coloca el cursor en

S1D13700_Display_Cursor (S1D13700_CURSOR_ON);
S1D13700_Write_Char
Prototipo void S1D13700_Write_Char ( carácter sin
signo c, sin signo int x, sin signo en
sí , modo sin signo );
Devoluciones Nada.
Descripción Escribe un carácter en la capa de texto actual de Glcd en

las coordenadas (x, y).
Parámetros:
 c: char para ser escrito.
 x: Posición char en el eje x (columna).
 y: Posición char en el eje y (fila).
Valor Descripción
En el modo OR, se pueden

mostrar texto y gráficos y los
datos están lógicamente "OR-
ed".
S1D13700_OVERLAY_OR Esta es la forma más común
de combinar texto y gráficos,
por ejemplo, etiquetas en
botones.
En este modo, los datos de

texto y gráficos se combinan
a través del "OR exclusivo"
S1D13700_OVERLAY_XOR lógico.<="" td=""
style="margin: 0px; padding:
0px;">
El texto y los datos gráficos

que se muestran en la pantalla
S1D13700_OVERLAY_AND se combinan a través de la
"función AND" lógica.

Ejemplo S1D13700_Write_Char ('A', 22,23,

S1D13700_OVERLAY_OR);
S1D13700_Write_Text
Prototipo void S1D13700_Write_Text ( unsigned char *
str, unsigned char x, unsigned char y, char mode);
Devoluciones Nada.
Descripción Escribe texto en el panel de texto actual de Glcd en las

coordenadas (x, y).
Parámetros:
 str: Texto a escribir.
 x: Posición del texto en el eje x (columna).
 y: Posición del texto en el eje y (fila).
Valor Descripción
En el modo OR, se pueden

mostrar texto y gráficos y los
datos están lógicamente "OR-
ed".
S1D13700_OVERLAY_OR Esta es la forma más común
de combinar texto y gráficos,
por ejemplo, etiquetas en
botones.
En este modo, los datos de

texto y gráficos se combinan
a través del "OR exclusivo"
S1D13700_OVERLAY_XOR lógico.<="" td=""
style="margin: 0px; padding:
0px;">
El texto y los datos gráficos

que se muestran en la pantalla
S1D13700_OVERLAY_AND se combinan a través de la
"función AND" lógica.

Ejemplo S1D13700_Write_Text ("EPSON LIBRARY DEMO, WELCOME!",

0, 0, S1D13700_OVERLAY_OR);
S1D13700_Dot
Prototipo void S1D13700_Dot ( int sin signo , int y sin
signo , color corto sin firmar );
Devoluciones Nada.
Descripción Dibuja un punto en el panel gráfico actual de Glcd en las

coordenadas (x, y).
Parámetros:
 x: Posición del punto en el eje x.
 y: Posición del punto en el eje y.
 color:parámetro de color Valores válidos:
Valor Descripción
S1D13700_BLACK De color negro.
S1D13700_WHITE El color blanco.
S1D13700_INVERT Invertir el color.

Ejemplo S1D13700_Dot (50, 50, S1D13700_WHITE);

S1D13700_Line
Prototipo void S1D13700_Line ( unsigned int x0, unsigned
int y0, unsigned intx1, unsigned int y1, unsigned
char pcolor);
Devoluciones Nada.
Descripción Dibuja una línea desde (x0, y0) a (x1, y1).

Parámetros:
 x0: Coordenada x de la línea de inicio.
 y0: Coordenada y del final de la línea.
 pcolor:parámetro de color Valores válidos:
Valor Descripción

Ejemplo S1D13700_Line (0, 0, 239, 127, S1D13700_WHITE);
S1D13700_H_Line
Prototipo void S1D13700_H_Line ( unsigned
int x_start, unsigned int x_end, unsigned
int y_pos, unsigned short color);
Devoluciones Nada.
Descripción Dibuja una línea horizontal.

Parámetros:
 x_start: Coordenada x de la línea de inicio.
 x_end: Coordenada x del final de la línea.
 y_pos: Posición de línea en el eje y.
Valor Descripción

S1D13700_V_Line
Prototipo void S1D13700_V_Line ( unsigned
int y_start, unsigned int y_end, unsigned
int x_pos, unsigned short color);
Devoluciones Nada.
Descripción Dibuja una línea horizontal.

Parámetros:
 y_start: Coordenada y de la línea de inicio.
 y_end: Coordenada y del final de la línea.
 x_pos: Posición de la línea en el eje x.
Valor Descripción

S1D13700_Rectangle
Prototipo void S1D13700_Rectangle ( unsigned
int x0, unsigned int y0, unsigned int x1, unsigned
int y1, unsigned char pcolor);
Devoluciones Nada.
Descripción Dibuja un rectángulo en Glcd.

Parámetros:
 x0: Coordenada x de la esquina superior
izquierda del rectángulo.
 y0: Coordenada y de la esquina superior
 x1: Coordenada x de la esquina inferior
derecha del rectángulo.
 y1: Coordenada y de la esquina inferior
derecha del rectángulo.
Valor Descripción

Ejemplo S1D13700_rectangle (20, 20, 219, 107,

S1D13700_WHITE);
S1D13700_Box
Prototipo void S1D13700_Box ( unsigned int x0, unsigned
int y0, unsigned intx1, unsigned int y1, unsigned
char pcolor);
Devoluciones Nada.
Descripción Dibuja una caja en Glcd.

Parámetros:
 x0: Coordenada x de la esquina superior
izquierda del cuadro.
 y0: Coordenada y de la esquina superior
izquierda del cuadro.
 x1: Coordenada x de la esquina inferior
derecha del cuadro.
 y1: Coordenada y de la esquina inferior
derecha del cuadro.
Valor Descripción

Ejemplo S1D13700_Box (0, 119, 239, 127, S1D13700_WHITE);
S1D13700_Rectangle_Round_Edges
Prototipo void S1D13700_Rectangle_Round_Edges ( sin signo
int x_upper_left, sin signo int y_upper_left, sin
signo int x_bottom_right, sin signo
int y_bottom_right, sin signo
corto round_radius, sin signo cortocolor);
Devoluciones Nada.
Descripción Dibuja un borde redondeado rectángulo en Glcd.

Parámetros:
 x_upper_left: Coordenada x de la esquina
superior izquierda del rectángulo.
 y_upper_left: Coordenada y de la esquina
 x_bottom_right: Coordenada x de la esquina
inferior derecha del rectángulo.
 y_bottom_right: Coordenada y de la esquina
 round_radius: Radio del borde redondeado.
Valor Descripción

Ejemplo S1D13700_Rectangle_Round_Edges (20, 20, 219, 107,

12, S1D13700_WHITE);
S1D13700_Rectangle_Round_Edges_Fill
Prototipo void S1D13700_Rectangle_Round_Edges_Fill ( int sin
signo x0, int y0 sin signo , int x1 sin
signo , int y1 sin signo, redondeo corto sin signo
sin signo, color corto sin signo );
Devoluciones Nada.
Descripción Dibuja un borde redondeado relleno en Glcd.

Parámetros:
Valor Descripción

Ejemplo S1D13700_Rectangle_Round_Edges_Fill (20, 20, 219,

107, 12, S1D13700_WHITE);
S1D13700_Circulo
Prototipo void S1D13700_Circle ( unsigned
int x_center, unsigned inty_center, unsigned
int radio, unsigned short color);
Devoluciones Nada.
Descripción Dibuja un círculo en Glcd.

Parámetros:
 x_center: Coordenada x del centro del círculo.
 y_center: Y coordenada del centro del círculo.
 radius: tamaño del radio.
Valor Descripción

Ejemplo S1D13700_Circle (120, 64, 110, S1D13700_WHITE);
S1D13700_Circle_Fill
Prototipo void S1D13700_Circle_Fill ( unsigned
int x_center, unsigned inty_center, unsigned
int radio, unsigned short color);
Devoluciones Nada.
Descripción Dibuja un círculo relleno en Glcd.
Parámetros:
 x_center: Coordenada x del centro del círculo.
 y_center: Y coordenada del centro del círculo.
 radius: tamaño del radio.
Valor Descripción

Ejemplo S1D13700_Circle_Fill (120, 64, 110, S1D13700_WHITE);
S1D13700_Imagen
Prototipo void S1D13700_Image ( const code char * pic);
Devoluciones Nada.
Descripción Muestra el mapa de bits en Glcd.

Parámetros:
 image:Imagen a mostrar. La matriz de mapa
de bits se encuentra en la memoria de código.
Nota: la dimensión de la imagen debe coincidir con

la dimensión de visualización.

Ejemplo S1D13700_Image (imagen);
S1D13700_Imagen parcial
Prototipo void S1D13700_PartialImage ( sin signo
int x_left, sin signo int y_top, sin signo
int ancho, sin signo int alto, sin signo
int picture_width, sin signo
int picture_height, código const sin signo corto *
imagen);
Devoluciones Nada.
Descripción Muestra un área parcial de la imagen en una ubicación

deseada.
Parámetros:
 x_left: Coordenada x de la ubicación deseada
(coordenada superior izquierda).
 y_top: Coordenada y de la ubicación deseada
 width: ancho de la imagen deseada.
 height: altura deseada de la imagen.
 picture_width: Ancho de la imagen original.
 picture_height: Altura de la imagen original.


Ejemplo // Dibuja una parte de la imagen de 10x15 a partir

de la esquina superior izquierda de la coordenada
(10,12). El tamaño de la imagen original es 16x32.
S1D13700_PartialImage (10, 12, 10, 15, 16, 32,
imagen);
Biblioteca Ethernet PIC18FxxJ60

PIC18FxxJ60familia de microcontroladores cuentan con un módulo controlador de
Ethernet incorporado. Esta es una solución de conectividad completa, que incluye
implementaciones completas de los módulos de control de acceso a medios (MAC) y
transceptor de capa física (PHY). Dos transformadores de pulso y algunos
componentes pasivos son todo lo que se requiere para conectar el microcontrolador
directamente a una red Ethernet.
El módulo Ethernet cumple con todas las especificaciones IEEE 802.3 para
conectividad 10-BaseT a una red de par trenzado. Incorpora una serie de esquemas
de filtrado de paquetes para limitar los paquetes entrantes. También proporciona
un módulo DMA interno para un rápido rendimiento de datos y cálculos de suma
de comprobación de IP asistidos por hardware . También se toman provisiones
para dos salidas LED para indicar la actividad del enlace y la red
Esta biblioteca ofrece la posibilidad de utilizar fácilmente la función Ethernet de
los MCU mencionados anteriormente .
La biblioteca Ethernet PIC18FxxJ60 admite:
 Protocolo IPv4.
 Solicitudes de ARP .
 Solicitudes de eco ICMP .
 Peticiones UDP
 Solicitudes de TCP (sin pila, sin reconstrucción de paquetes).
 Cliente ARP con caché.
 Cliente DNS
 Cliente UDP
 Cliente DHCP
 La fragmentación de paquetes NO es compatible.
Importante:
 La variable de biblioteca global Ethernet_userTimerSecse utiliza para
realizar un seguimiento del tiempo para todas las implementaciones de
clientes ( ARP , DNS , UDP y DHCP ). Es responsabilidad del usuario
incrementar esta variable cada segundo en su código si se utiliza alguno
de los clientes.
 Para usuarios avanzados, hay archivos de encabezado
( "eth_j60LibDef.h"y "eth_j60LibPrivate.h") en la carpeta Uses \
P18 del compilador con una descripción de todas las rutinas y variables
globales, relevantes para el usuario, implementadas en la biblioteca
Ethernet PIC18FxxJ60.
 Ethernet_Init
 Ethernet_Enable
 Ethernet_Disable
 Ethernet_doPacket
 Ethernet_putByte
 Ethernet_putBytes
 Ethernet_putString
 Ethernet_putConstString
 Ethernet_putConstBytes
 Ethernet_getByte
 Ethernet_getBytes
 Ethernet_UserTCP
 Ethernet_UserUDP
 Ethernet_getIpAddress
 Ethernet_getGwIpAddress
 Ethernet_getDnsIpAddress
 Ethernet_getIpMask
 Ethernet_confNetwork
 Ethernet_arpResolve
 Ethernet_sendUDP
 Ethernet_dnsResolve
 Ethernet_initDHCP
 Ethernet_doDHCPLeaseTime
 Ethernet_renewDHCP
Ethernet_Init
Prototipo void Ethernet_Init ( unsigned char * mac, unsigned
char * ip, unsigned char fullDuplex);
Devolucione Nada.
s
Descripción Esta es la rutina del módulo MAC . Inicializa el controlador

de Ethernet. Esta función se divide internamente en 2
partes para ayudar al enlazador cuando se queda corto de
memoria.
Configuración del controlador de Ethernet (los parámetros
que no se mencionan aquí están configurados de forma
predeterminada):
 recibir dirección de inicio búfer: 0x0000.
 recibir el extremo del tope dirección: 0x19AD.
 transmitir dirección de inicio búfer: 0x19AE.
 transmitir la dirección final buffer: 0x1FFF.
 Memoria RAM de lectura / escritura de
punteros en modo de incremento automático.
 los filtros de recepción se establecen en
los valores predeterminados: CRC + MAC Uni
cast + MAC Broadcast en modo OR.
 Control de flujo con cuadros de pausa de TX y
RX en modo dúplex completo.
 Los cuadros se rellenan a 60bytes + CRC .
 El tamaño máximo de paquete se establece
en 1518.
 Intervalo entre paquetes de respaldo: 0x15en
modo dúplex completo; 0x12en modo half
duplex.
 Intervalo entre paquetes sin respaldo: 0x0012en
modo dúplex completo; 0x0C12en modo half
duplex.
 loopback semidúplex desactivado.
 Configuración de LED : por defecto (estado de
enlace LEDA, actividad de enlace LEDB).
Parámetros:
 mac: Búfer RAM que contiene
una dirección MAC válida .
 ip: Búfer RAM que contiene
una dirección IP válida .
 fullDuplex:Interruptor de modo dúplex
Ethernet. Valores válidos: 0(modo semidúplex)
y 1(modo dúplex completo).
Nota: Si se va a
utilizar un servidor DHCP , la dirección IP debe
configurarse en 0.0.0.0.
Requiere Nada.
Ejemplo #define Ethernet_HALFDUPLEX 0

#define Ethernet_FULLDUPLEX 1
unsigned char myMacAddr [6] = {0x00, 0x14, 0xA5,

0x76, 0x19, 0x3f}; // mi dirección MAC
no firmada char myIpAddr = {192, 168, 1, 60}; // mi
dirección IP
Ethernet_Init (myMacAddr, myIpAddr,

Ethernet_FULLDUPLEX);
Ethernet_Enable
Prototipo void Ethernet_Enable ( unsigned char enFlt);
Devolucio Nada.
nes
Descripci Esta es la rutina del módulo MAC . Esta rutina habilita el

ón tráfico de red apropiado en el módulo Ethernet interno
de la MCUpor medio de sus filtros de recepción (unicast,
multicast, broadcast, crc). El tipo específico de tráfico de red se
habilitará si se establece un bit correspondiente del parámetro
de entrada de esta rutina. Por lo tanto, se puede habilitar más
de un tipo de tráfico de red al mismo tiempo. Para este
propósito, las constantes de biblioteca predefinidas (consulte la
tabla a continuación) se pueden ORed para formar el valor de
entrada apropiado.
Parámetros:
 enFlt:tráfico de red / recibir banderas de
filtro. Cada bit corresponde al filtro de tráfico /
recepción de red apropiado:
Po Másc Biblioteca
Descripción
co ara predefinida const
Tráfico de
difusión MAC /
indicador de
filtro de
recepción.Cuand _Ethernet_BROA
0 0x01 o se DCAST
establece, el tráfi
co de
transmisión MA
C se habilitará.
Tráfico de
multidifusión M
AC / indicador
de filtro de
recepción. Cuand _Ethernet_MULT
1 0x02 ICAST
o se establece, se
habilitará el
tráfico de
multidifusión M
AC .
2 0x04 no utilizado ninguna
CRC marca
de verificación.
Cuando se
5 0x20 establece, los _Ethernet_CRC
paquetes con
el campo CRC n
o válido se
descartarán.

Tráfico de
unidifusión MA
C / indicador de
filtro de
recepción.Cuand _Ethernet_UNIC
7 0x80 o se AST
co de
unidifusión MA
C se habilitará.
Nota :
 El filtrado avanzado está disponible en
el módulo Ethernet interno de la MCU ,
por ejemplo Pattern Match, Magic
Packety Hash Tableno se puede
habilitar con esta rutina.
Además, todos los filtros,
excepto CRC , habilitados con esta
rutina funcionarán en modo OR, lo que
significa que el paquete se recibirá si
alguno de los filtros habilitados lo
acepta.
 Esta rutina cambiará la configuración
del filtro de recepción sobre la
marcha. De ninguna manera, no
interferirá con la activación /
desactivación de la lógica de recepción
/ transmisión o cualquier otra parte
del módulo Ethernet interno de
la MCU .
El módulo Ethernet interno de
la MCU debe estar correctamente
configurado por medio de
la rutina Ethernet_Init .
Requiere El módulo de Ethernet tiene que ser

inicializado. Ver Ethernet_Init .
Ejemplo Ethernet_Enable (_Ethernet_CRC | _Ethernet_UNICAST); //

habilitar el control de CRC y el tráfico de unidifusión
Ethernet_Disable
Prototipo void Ethernet_Disable ( unsigned char disFlt);
Devolucio Nada.
nes
Descripci Esta es la rutina del módulo MAC . Esta rutina desactiva el

ón tráfico de red apropiado en el módulo Ethernet interno
de la MCU por medio de sus filtros de recepción (unicast,
multicast, broadcast, crc). El tipo específico de tráfico de red se
desactivará si se establece un bit correspondiente del
parámetro de entrada de esta rutina. Por lo tanto, más de un
tipo de tráfico de red se puede desactivar al mismo
tiempo. Para este propósito, las constantes de biblioteca
predefinidas (consulte la tabla a continuación) se pueden ORed
para formar el valor de entrada apropiado.
Parámetros:
 disFlt:tráfico de red / recibir banderas de
Po Másc Biblioteca
Descripción
Tráfico de
difusión MAC /
indicador de
filtro de
recepción. Cuand
o se _Ethernet_BROA
0 0x01 DCAST
co de
transmisión MA
C se
deshabilitará.
Tráfico de
multidifusión M
AC / indicador
de filtro de
recepción. Cuand
_Ethernet_MULT
1 0x02 o se
ICAST
co de
multidifusión M
AC se
deshabilitará.
CRC marca
de verificación.
Cuando se
establece,
5 0x20 _Ethernet_CRC
la verificación C
RCse
deshabilitará y se
aceptarán los
paquetes con
el campo CRC n
o válido .
Tráfico de
unidifusión MA
C / indicador de
filtro de
recepción. Cuand
_Ethernet_UNIC
7 0x80 o se
AST
co de
unidifusión MA
C se
deshabilitará.
Nota :
el módulo Ethernet interno de la MCU ,
por ejemplo Pattern Match, Magic
desactivar con esta rutina.
interferirá con la activación /
desactivación de la lógica de recepción
/ transmisión o cualquier otra parte
del módulo Ethernet interno de
la MCU .
 El módulo Ethernet interno de
la MCU debe estar correctamente
la rutina Ethernet_Init .

Ejemplo Ethernet_Disable (_Ethernet_CRC | _Ethernet_UNICAST); //

deshabilitar la comprobación de CRC y el tráfico de
unidifusión
Ethernet_doPacket
Prototipo unsigned char Ethernet_doPacket ();
Devoluciones  0 - después del procesamiento exitoso de

paquetes (cero paquetes recibidos o recibidos
paquete procesado exitosamente).
 1- En caso de error de recepción o recibir
corrupción del búfer. El controlador de Ethernet
necesita ser reiniciado.
 2- el paquete recibido no nos fue enviado (ni
nuestra dirección IP , ni nuestra dirección de
transmisión IP ).
 3- El paquete IP recibido no fue IPv4.
 4 - El paquete recibido fue de tipo desconocido
para la biblioteca.
Descripción Esta es la rutina del módulo MAC . Procesa el siguiente

paquete recibido si existe. Los paquetes se procesan de la
siguiente manera:
 Las solicitudes de ARP e ICMP son
contestadas automáticamente.
 sobre TCP petición
del Ethernet_UserTCP función se llama para su
posterior procesamiento.
 sobre UDP solicitud
la Ethernet_UserUDP función se llama para su
Nota: Ethernet_doPacket debe llamarse tan a

menudo como sea posible en el código del usuario.

Ejemplo if (Ethernet_doPacket () == 0) { // procesar

paquetes recibidos
...
}
Ethernet_putByte
Prototipo void Ethernet_putByte ( unsigned char v);
Devoluciones Nada.
Descripción Esta es la rutina del módulo MAC . Almacena un byte a la

dirección señalada por el puntero de escritura del
controlador Ethernet actual ( EWRPT).
Parámetros:
 v: valor para almacenar

Ejemplo datos de char_;

...
Ethernet_putByte (data_); // poner un byte en el
búfer del controlador de Ethernet
Ethernet_putBytes
Prototipo void Ethernet_putBytes ( unsigned char *
ptr, unsigned int n);
Devoluciones Nada.
Descripción Esta es la rutina del módulo MAC . Almacena el número

solicitado de bytes en la memoria RAM del controlador
Ethernet a partir de la EWRPTubicación del puntero de
escritura ( ) del controlador Ethernet actual .
Parámetros:
 ptr: RAM buffer que contiene bytes para
escribir en la memoria RAM del controlador
Ethernet .
 n: Número de bytes a escribir.

Ejemplo char * buffer = "mikroElektronika";

...
Ethernet_putBytes (buffer, 16); // poner una matriz
de RAM en el búfer del controlador de Ethernet
Ethernet_putConstBytes
Prototipo void Ethernet_putConstBytes ( const unsigned
char * ptr, unsigned int n);
Devoluciones Nada.

solicitado de bytes const en la memoria RAM del
controlador de Ethernet a partir de la EWRPTubicación
del puntero de escritura ( ) del controlador de Ethernet
actual .
Parámetros:
 ptr:búfer const que contiene bytes para
escribir en la memoria RAM del controlador
Ethernet .

Ejemplo const char * buffer = "mikroElektronika";

...
Ethernet_putConstBytes (buffer, 16); // poner una
matriz const en el búfer del controlador de Ethernet
Ethernet_putString
Prototipo unsigned int Ethernet_putString ( unsigned char *
ptr);
Devoluciones Número de bytes escritos en la memoria RAM del
controlador Ethernet .
Descripción Esta es la rutina del módulo MAC . Almacena toda la

cadena (excluyendo la terminación nula) en la memoria
RAM del controlador Ethernet a partir de la EWRPTubicación
del puntero de escritura ( ) del controlador Ethernet
actual .
Parámetros:
 ptr:cadena para escribir en la memoria
RAM del controlador Ethernet .


...
Ethernet_putString (buffer); // poner una cadena de
RAM en el búfer del controlador de Ethernet
Ethernet_putConstString
Prototipo unsigned int Ethernet_putConstString ( const
unsigned char * ptr);
Devoluciones Número de bytes escritos en la memoria RAM del

controlador Ethernet .

cadena de const (excluyendo la terminación nula) en
la RAM del controlador Ethernet a partir de
la EWRPTubicación del puntero de escritura ( ) del
controlador Ethernet actual .
Parámetros:
 ptr:cadena constante para escribir en
la memoria RAM del controlador Ethernet .


...
Ethernet_putConstString (búfer); // poner una cadena
constante en el búfer del controlador de Ethernet
Ethernet_getByte
Prototipo unsigned char Ethernet_getByte ();
Devoluciones Byte leído desde la memoria RAM del controlador

Ethernet .
Descripción Esta es la rutina del módulo MAC . Obtiene un byte desde
la dirección señalada por el puntero de lectura del
controlador Ethernet actual ( ERDPT).

Ejemplo char buffer;

...
buffer = Ethernet_getByte (); // leer un byte desde
el búfer del controlador de Ethernet
Ethernet_getBytes
Prototipo void Ethernet_getBytes ( unsigned char *
ptr, unsigned int addr, unsigned int n);
Devoluciones Nada.
Descripción Esta es la rutina del módulo MAC . Obtiene el número de

bytes asimilados de la memoria RAM del controlador
Ethernet a partir de la dirección dada. Si 0xFFFFse pasa
el valor de como parámetro de dirección, la lectura
comenzará desde la ERDPTubicación del puntero de lectura
( ) del controlador Ethernet actual .
Parámetros:
 ptr:búfer para almacenar bytes leídos de
la memoria RAM del controlador de
Ethernet .
 addr:Dirección de inicio RAM del controlador
Ethernet . Los valores válidos: 0.. 8192.
 n: Número de bytes a leer.

Ejemplo búfer de char [16];

...
Ethernet_getBytes (buffer, 0x100, 16); // leer 16
bytes, comenzando desde la dirección 0x100
Ethernet_UserTCP
Prototipo unsigned int Ethernet_UserTCP ( unsigned char *
remoteHost, unsigned int remotePort, unsigned
int localPort, unsigned
int reqLength, TEthPktFlags * flags);
Devoluciones  0 - No debe haber una respuesta a la solicitud.

 Longitud del campo de datos de
respuesta TCP / HTTP - de lo contrario.
Descripción Esta es la rutina del módulo TCP . Se llama internamente
por la biblioteca. El usuario accede a
la solicitud TCP / HTTP utilizando algunas de las rutinas
Ethernet_get. El usuario coloca datos en el búfer de
transmisión utilizando algunas de las rutinas
Ethernet_put. La función debe devolver la longitud en
bytes de la respuesta TCP / HTTP , o 0 si no hay nada
que transmitir. Si no hay necesidad de responder a
las solicitudes TCP / HTTP , simplemente defina esta
función con return (0) como una sola declaración.
Parámetros:
 remoteHost:Dirección IP del cliente .
 remotePort:puerto TCP del cliente .
 localPort: Puerto al que se envía la solicitud.
 reqLength: Longitud de campo de datos de
solicitud TCP / HTTP .
 flags: La estructura consistía en dos campos
de bits:
typedef struct {
unsigned canCloseTCP: 1; // indicador
que cierra el socket
sin firmar isBroadcast: 1; // indicador
que indica que el paquete IP se ha
recibido a través de la dirección de
difusión de subred (no se utiliza para la
familia PIC16)
} TEthPktFlags;
Nota: El código fuente de la función se

proporciona con proyectos de ejemplo
apropiados. El código debe ser ajustado por el
usuario para lograr la respuesta deseada.

Ejemplo Esta función es llamada internamente por la biblioteca y no

debe ser llamada por el código del usuario.
Ethernet_UserUDP
Prototipo unsigned int Ethernet_UserUDP ( unsigned char *
remoteHost, unsigned int remotePort, unsigned
int destPort, unsigned

respuesta UDP - de lo contrario.
Descripción Esta es la rutina del módulo UDP . Se llama internamente

la solicitud UDP utilizando algunas de las rutinas
Ethernet_get. El usuario coloca datos en el búfer de
transmisión utilizando algunas de las rutinas
Ethernet_put. La función debe devolver la longitud en
bytes de la respuesta UDP , o 0 si no hay nada que
transmitir. Si no necesita responder a las solicitudes UDP ,
simplemente defina esta función con un retorno (0) como
una sola declaración.
Parámetros:
 remotePort: Puerto del cliente.
 destPort: Puerto al que se envía la solicitud.
de bits:
typedef struct {
unsigned canCloseTCP: 1; // el
indicador que cierra el socket TCP (no
relevante para UDP)
sin firma isBroadcast: 1; // indicador
familia PIC16)
} TEthPktFlags;



Ethernet_getIpAddress
Prototipo unsigned char * Ethernet_getIpAddress ();
Devoluciones Puntero a la variable global con dirección IP .
Descripción Esta rutina debe usarse cuando el servidor DHCP está

presente en la red para obtener la dirección IP asignada .
Nota: El usuario siempre debe copiar

la dirección IP de la ubicación de RAM que devuelve esta
rutina en su propio búfer de dirección IP . ¡Estas
ubicaciones no deben ser alteradas por el usuario en
ningún caso!
Ejemplo unsigned char ipAddr [4]; // búfer de direcciones

IP de usuario
...
memcpy (ipAddr, Ethernet_getIpAddress (), 4); //
obtener la dirección IP
Ethernet_getGwIpAddress
Prototipo unsigned char * Ethernet_getGwIpAddress ();
Devoluciones Puntero a la variable global que contiene la dirección IP

de la puerta de enlace .

presente en la red para obtener la dirección IP de
lapuerta de enlace asignada .
rutina en su propio búfer de dirección IP de puerta de
enlace . ¡Estas ubicaciones no deben ser alteradas por el
usuario en ningún caso!

Ejemplo unsigned char gwIpAddr [4]; // búfer de direcciones

IP de la puerta de enlace del usuario
...
memcpy (gwIpAddr, Ethernet_getGwIpAddress (), 4); //
obtener la dirección IP de la puerta de enlace
Ethernet_getDnsIpAddress ();
Prototipo unsigned char * Ethernet_getDnsIpAddress

del DNS .
Descripción Esta rutina se debe usar cuando el servidor DHCP está

presente en la red para obtener la dirección IPasignada
del DNS .

rutina en su propio búfer de dirección IP de DNS . ¡Estas
ningún caso!
Ejemplo unsigned char dnsIpAddr [4]; // búfer de dirección

IP de usuario DNS
...
memcpy (dnsIpAddr, Ethernet_getDnsIpAddress (), 4);
// obtener la dirección del servidor DNS
Ethernet_getIpMask
Prototipo unsigned char * Ethernet_getIpMask ()
Devoluciones Puntero a la variable global que contiene la máscara de

subred IP .

presente en la red para recuperar la máscara de
subred IP asignada .

rutina en su propio búfer de máscara de subred IP . ¡Estas
ningún caso!

Ejemplo unsigned char IpMask [4]; // búfer de máscara de

subred IP de usuario
...
memcpy (IpMask, Ethernet_getIpMask (), 4); //
obtener máscara de subred IP
Ethernet_confNetwork
Prototipo void Ethernet_confNetwork ( char * ipMask, char *
gwIpAddr, char * dnsIpAddr);
Devoluciones Nada.
Descripción Configura los parámetros de red ( IP máscara de subred,

puerta de enlace IP dirección, DNS IP dirección)
cuando DHCP no se utiliza.
Parámetros:
 ipMask: Máscara de subred IP .
 gwIpAddrDirección IP de la puerta de enlace .
 dnsIpAddr: Dirección IP del DNS .
Nota: los parámetros de red mencionados
anteriormente deben configurarse con esta rutina solo si no
se utiliza el módulo DHCP . De lo
contrario, DHCP anulará esta configuración.

Ejemplo unsigned char ipMask [4] = {255, 255, 255, 0}; //

máscara de red (por ejemplo: 255.255.255.0)
unsigned char gwIpAddr [4] = {192, 168, 1, 1}; //
dirección IP de la puerta de enlace (enrutador)
unsigned char dnsIpAddr [4] = {192, 168, 1, 1}; //
dirección IP del servidor DNS
...
Ethernet_confNetwork (ipMask, gwIpAddr, dnsIpAddr);
// establecer los parámetros de configuración de red
Ethernet_arpResolve
Prototipo unsigned char * Ethernet_arpResolve ( unsigned
char * ip, unsigned char tmax);
Devoluciones  MAC dirección detrás de la IP Address - La

solicitado IP dirección se resolvió.
Descripción Esta es la rutina del módulo ARP . Envía una solicitud

de ARP para una dirección IP determinada y espera
la respuesta de ARP . Si se
resolvió ladirección IP solicitada , se utiliza una entrada de
efectivo ARP para almacenar la configuración. ARP Cash
puede almacenar hasta 3 entradas. Para la estructura de
efectivo de ARP , consulte el "eth_j60LibDef.h"archivo de
encabezado en la carpeta Uses / P18 del compilador.
Parámetros:
 ip: Dirección IP a resolver.
 tmax: tiempo en segundos para esperar una
respuesta.
Nota: Los servicios de Ethernet no se detienen

mientras esta rutina espera la respuesta de ARP . Los
paquetes entrantes se procesarán normalmente durante
este tiempo.

Ejemplo unsigned char IpAddr [4] = {192, 168, 1, 1}; //

Dirección IP
...
Ethernet_arpResolve (IpAddr, 5); // obtener la
dirección MAC detrás de la dirección IP anterior,
espere 5 segundos para la respuesta
Ethernet_sendUDP
Prototipo unsigned char Ethernet_sendUDP ( unsigned char *
destIP, unsigned int sourcePort, unsigned
int destPort, unsigned char * pkt, unsigned
intpktLen);
Devoluciones  1- El paquete UDP fue enviado exitosamente.

Descripción Esta es la rutina del módulo UDP . Envía

un paquete UDP en la red.
Parámetros:
 destIP:Dirección IP del host remoto .
 sourcePort:Número de puerto de
origen UDP local .
 destPort:número de puerto UDP de destino .
 pkt: paquete para transmitir.
 pktLen: Longitud en bytes del paquete a
transmitir.


dirección IP remota
...
Ethernet_sendUDP (IpAddr, 10001, 10001, "Hola", 5);
// enviar el mensaje de saludo a la dirección IP
anterior, desde el puerto UDP 10001 al puerto UDP
10001
Ethernet_dnsResolve
Prototipo unsigned char * Ethernet_dnsResolve ( unsigned
char * host, unsigned char tmax);
Devoluciones  puntero a la ubicación donde se encuentra

la dirección IP : se resolvió el nombre de host
solicitado.
Descripción Esta es la rutina del módulo DNS . Envía una solicitud

de DNS para el nombre de host dado y espera
la respuesta de DNS . Si el nombre de host solicitado se
resolvió, su dirección IP se almacena en la variable global
de la biblioteca y la rutina devuelve un puntero que
contiene esta dirección. El puerto UDP53 se utiliza
como puerto DNS .
Parámetros:
 host: Nombre de host a resolver.
respuesta.
Los parámetros de red mencionados anteriormente deben
configurarse con esta rutina solo si no se utiliza el
módulo DHCP . De lo contrario, DHCP anulará esta
configuración.
Nota :
 Los servicios de Ethernet no se detienen
mientras esta rutina espera la respuesta
del DNS . Los paquetes entrantes se
procesarán normalmente durante este tiempo.
 El usuario siempre debe copiar
la dirección IP de la ubicación de RAM
que devuelve esta rutina en su propio búfer de
dirección IP del host resuelto . ¡Estas
ubicaciones no deben ser alteradas por el

Ejemplo unsigned char * remoteHostIpAddr [4]; // búfer de

direcciones IP del host del usuario
...
// servidor SNTP:
// Zurich, Suiza: Integrated Systems Lab, Swiss Fed.
Inst. de tecnología
// 129.132.2.21: swisstime.ethz.ch
// Área de servicio: Suiza y Europa
memcpy (remoteHostIpAddr, Ethernet_dnsResolve
("swisstime.ethz.ch", 5), 4);
Ethernet_initDHCP
Prototipo unsigned char Ethernet_initDHCP ( unsigned
char tmax);
Devoluciones  1 - Los parámetros de red se obtuvieron

exitosamente.
Descripción Esta es la rutina del módulo DHCP . Envía

una solicitud DHCP para los parámetros de red ( IP ,
puerta de enlace, direcciones DNS y máscara de
subred IP ) y espera la respuesta de DHCP . Si los
parámetros solicitados se obtuvieron con éxito, sus valores
se almacenan en las variables globales de la biblioteca.
Estos parámetros se pueden obtener utilizando las rutinas
de obtención de IP de la biblioteca adecuadas :
 Ethernet_getIpAddress -
captura la dirección IP .
 Ethernet_getGwIpAddress -
busca la dirección IP de la puerta de enlace .
 Ethernet_getDnsIpAddress -
recupera la dirección IP del DNS .
 Ethernet_getIpMask - obtener máscara de
subred IP .
El puerto UDP68 se utiliza como puerto de
cliente DHCP y el puerto UDP67 se utiliza como puerto de
servidor DHCP .
Parámetros:
respuesta.
Nota :
 Cuando se usa el módulo DHCP , la variable
de biblioteca global Ethernet_userTimerSecse
usa para mantener un registro del tiempo. Es
responsabilidad del usuario incrementar esta
variable cada segundo en su código.

Ejemplo ...
Ethernet_initDHCP (5); // obtener la configuración
de red del servidor DHCP, espere 5 segundos para
obtener la respuesta
...
Ethernet_doDHCPLeaseTime
Prototipo unsigned char Ethernet_doDHCPLeaseTime ();
Devoluciones  0 - El tiempo de arrendamiento aún no ha

expirado.
 1 - El tiempo de arrendamiento ha expirado, es
hora de renovarlo.
Descripción Esta es la rutina del módulo DHCP . Se encarga

del tiempo de concesión de la dirección IPal disminuir el
contador de la biblioteca de tiempo de concesión
global. Cuando este tiempo expire, es hora de contactar
al servidor DHCP y renovar el contrato de arrendamiento.

Ejemplo mientras (1) {

...
if (Ethernet_doDHCPLeaseTime ())
... // es hora de renovar el arrendamiento de la
dirección IP
}
Ethernet_renewDHCP
Prototipo unsigned char Ethernet_renewDHCP ( unsigned
char tmax);
Devoluciones  1 - En caso de éxito (el tiempo de

arrendamiento fue renovado).
 0 - De lo contrario (solicitud de renovación
expirada).
Descripción Esta es la rutina del módulo DHCP . Envía la solicitud de

renovación del tiempo de concesión de la
dirección IP al servidor DHCP .
Parámetros:
respuesta.


...
if (Ethernet_doDHCPLeaseTime ())
Ethernet_renewDHCP (5); // es hora de renovar el
arrendamiento de la dirección IP, con 5 segundos
para una respuesta
...
}
Este código muestra cómo usar la biblioteca Ethernet PIC18FxxJ60:
 La junta responderá a las solicitudes de eco de ARP e ICMP.
 La junta responderá a las solicitudes UDP en cualquier puerto:
 devuelve la solicitud en caracteres superiores con un
encabezado hecho de IP de host remoto y número de
puerto
 la placa responderá a las solicitudes HTTP en el puerto 80, método GET
con rutas de acceso:
 / volverá a la página principal de HTML
 / s devolverá el estado del tablero como cadena de texto
 / t0 ... / t7 cambiará de RD0 a RD7 bit y devolverá la
página principal HTML
 Todas las demás solicitudes devuelven también la página
principal HTML.
#include "__EthJ60.h"
#define Ethernet_HALFDUPLEX 0
#define Ethernet_FULLDUPLEX 1
/ ************************************************** ***********
* ROM cadenas constantes
* /
const unsigned char httpHeader [] = "HTTP / 1.1 200 OKnContent-type:"; //
encabezado HTTP
const unsigned char httpMimeTypeHTML [] = "text / htmlnn"; //
HTML MIME type
const unsigned char httpMimeTypeScript [] = "text / plainnn"; //
TEXT MIME type
unsigned char httpMethod [] = "GET /";
/ *
* página web, dividida en 2 partes:
* cuando se queda corto de ROM, los datos fragmentados se manejan de
manera más eficiente por el enlazador
*
* esta página HTML llama a los tableros para obtener su estado y se
construye con javascript
* /
const char * indexPage = // Cambiar la dirección IP
de la página para actualizar
"<meta http-equiv =" refresh "content =" 3; url = http: //192.168.20.60 ">
<HTML><HEAD></HEAD> <BODY>
<h1> Mini servidor web PIC18FxxJ60 </h1>
<a href=/> Recargar </a>
<script src = / s> </script>
<table> <tr> <td valign = top> <table border = 1 style = "font-size: 20px;
font-family: terminal;">
<tr> <th colspan = 2> ADC </th> </tr>
<tr><td>AN2</td><td><script>document.write(AN2)</script></td> </tr>
</table></td> <td> <table border = 1 style = "font-size: 20px; font-
family: terminal;">
<tr> <th colspan = 2> PORTB </th> </tr>
<script>
var str, i;
str = "";
para (i = 0; i <8; i ++)
{str + = "<tr> <td bgcolor = pink> BUTTON #" + i + "</td>";
if (PORTB & (1 << i)) {str + = "<td bgcolor = red> ON";}
else else {str + = "<td bgcolor = # cccccc> OFF";}
str + = "</td> </tr>";}
document.write (str);
</script>
";
const char * indexPage2 = "</table> </td> <td>

<table border = 1 style = "font-size: 20px; font-family: terminal;">
<tr> <th colspan = 3> PORTD </th> </tr>
<script>
var str, i;
str = "";
para (i = 0; i <3; i ++)
{str + = "<tr> <td bgcolor = yellow> LED #" + i + "</td>";
if (PORTD & (1 << i)) {str + = "<td bgcolor = red> ON";}
str + = "</td> <td> <a href=/t"+i+"> Toggle </a> </td> </tr>";}
</script>
</table></td></tr> </table>
Esta es la solicitud HTTP # <script> document.write (REQ) </script>
</BODY> </HTML>
";
/ ***********************************
* RAM variables
* /
unsigned char myMacAddr [6] = {0x00, 0x14, 0xA5, 0x76, 0x19, 0x3f};
// mi dirección MAC
no firmada char myIpAddr [4] = {192, 168, 20, 60}; //
mi dirección IP
no firmada char gwIpAddr [4] = {192, 168, 20, 6}; //
dirección IP de la puerta de enlace (enrutador)
sin signo char ipMask [4] = {255, 255, 255, 0}; //
máscara de red (por ejemplo: 255.255.255.0)
unsigned char dnsIpAddr [4] = {192, 168, 20, 1}; //
dirección IP del servidor DNS
unsigned char getRequest [15];

// HTTP request buffer
unsigned char dyna [30];
// buffer para respuesta dinámica
sin signo largo httpCounter = 0;
// contador de peticiones HTTP
/ *******************************************
* funciones
* /
/ *
* ponga la cadena constante apuntada por s al búfer de transmisión del
controlador Ethernet.
* /
/ * unsigned int putConstString (const char * s)
{
unsigned int ctr = 0;
mientras (* s)
{
Ethernet_putByte (* s ++);
ctr ++;
}
retorno (ctr);
} * /
/ *
* será mucho más rápido usar la rutina Ethernet_putConstString de la
biblioteca
* En lugar de la rutina putConstString anterior. Sin embargo, el código
será un poco
* un poco más grande. El usuario debe elegir entre tamaño y velocidad y
elegir la implementación que
* le encomienda mejor. Si elige ir con la definición putConstString
anterior
* la línea #define a continuación debe ser comentada.
*
* /
#define putConstString Ethernet_putConstString
/ *
* ponga la cadena apuntada por s al búfer de transmisión del controlador
Ethernet
* /
/ * unsigned int putString (char * s)
{
mientras (* s)
{
Ethernet_putByte (* s ++);
ctr ++;
}
retorno (ctr);
} * /
/ *
* será mucho más rápido usar la rutina Ethernet_putString de la
biblioteca
* En lugar de la rutina putString anterior. Sin embargo, el código será
un poco
* le encomienda mejor. Si elige ir con la definición de putString
anterior
*
* /
#define putString Ethernet_putString
/ *
* Esta función es llamada por la biblioteca.
* el usuario accede a la solicitud HTTP mediante llamadas sucesivas a
Ethernet_getByte ()
* el usuario coloca datos en el búfer de transmisión mediante llamadas
sucesivas a Ethernet_putByte ()
* la función debe devolver la longitud en bytes de la respuesta HTTP, o 0
si no hay nada que transmitir
*
* Si no necesita responder a las solicitudes HTTP,
* simplemente defina esta función con un retorno (0) como una sola
declaración
*
* /
unsigned int Ethernet_UserTCP ( unsigned char * remoteHost, unsigned
int remotePort, unsigned int localPort, unsigned int reqLength,
TEthPktFlags * flags)
{
unsigned int len = 0; // mi respuesta
longitud
unsigned char i; // char de propósito
general
// ¿deberíamos cerrar el socket TCP después de enviar la

respuesta?
// la biblioteca cierra el socket tcp de forma predeterminada si
canClose flag no se restablece aquí
// flags-> canCloseTCP = 0; // 0 - no cerrar socket
// de lo contrario - cerrar socket
if (localPort! = 80) // Escucho solo la

solicitud web en el puerto 80
{
retorno (0);
}
// obtener 10 primeros bytes solo de la solicitud, el resto no

importa aquí
para (i = 0; i <10; i ++)
{
getRequest [i] = Ethernet_getByte ();
}
getRequest [10] = 0;
if (memcmp (getRequest, httpMethod, 5)) // solo se admite
el método GET aquí
{
retorno (0);
}
httpCounter ++; // una solicitud más

hecha
if (getRequest [5] == 's') // si el nombre de

la ruta de solicitud comienza con s, almacene datos dinámicos en el búfer
de transmisión
{
// la cadena de texto respondida por esta solicitud puede
interpretarse como declaraciones de javascript
// por los navegadores
len = putConstString (httpHeader); //

encabezado HTTP
len + = putConstString (httpMimeTypeScript); // con
texto tipo MIME
// agregar el valor AN2 a la respuesta

IntToStr (ADC_Read (2), dyna);
len + = putConstString ("var AN2 =");
len + = putString (dyna);
len + = putConstString (";");
// agregar valor AN3 a la respuesta

// agregar valor PORTB (botones) para responder

len + = putConstString ("var PORTB =");
IntToStr (PORTB, dyna);
// agregar valor PORTD (LEDs) a la respuesta

len + = putConstString ("var PORTD =");
IntToStr (PORTD, dyna);
// añadir el contador de solicitudes HTTP para responder

IntToStr (httpCounter, dyna);
len + = putConstString ("var REQ =");
}
else if (getRequest [5] == 't') // si
el nombre de la ruta de la solicitud comienza con t, alterna el número de
bit PORTD (LED) que viene después
{
bitMask de caracteres sin signo = 0;
// para máscara de bits
if (isdigit (getRequest [6])) // si

0 <= número de bit <= 9, los bits 8 y 9 no existen pero no importan
{
bitMask = getRequest [6] - '0'; //
convertir ASCII en entero
bitMask = 1 << bitMask; // crear
máscara de bits
PORTD ^ = bitMask; //
alternar PORTD con el operador xor
}
}
if (len == 0) // que
hacer por defecto
{
encabezado HTTP
len + = putConstString (httpMimeTypeHTML); // con
HTML MIME type
len + = putConstString (indexPage); // página
HTML primera parte
len + = putConstString (indexPage2); //
segunda parte de la página HTML
}
retorno (len); // volver

a la biblioteca con el número de bytes a transmitir
}
/ *
* el usuario accede a la solicitud UDP mediante llamadas sucesivas a
Ethernet_getByte ()
sucesivas a Ethernet_putByte ()
* la función debe devolver la longitud en bytes de la respuesta UDP, o 0
*
* Si no necesita responder a las solicitudes UDP,
declaración
*
* /
unsigned int Ethernet_UserUDP ( unsigned char * remoteHost, unsigned
int remotePort, unsigned int destPort, unsigned int reqLength,
{
unsigned int len; // la duración de
mi respuesta
// se hace la respuesta de la dirección IP del host remoto en

formato legible por humanos
ByteToStr (remoteHost [0], dyna); // primer byte de
dirección IP
dyna [3] = '.' ;
ByteToStr (remoteHost [1], dyna + 4); // segundo
dyna [7] = '.' ;
ByteToStr (remoteHost [2], dyna + 8); // tercero
dyna [11] = '.' ;
ByteToStr (remoteHost [3], dyna + 12); // cuarto
dyna [15] = ':'; // agregar

separador
// luego el número de puerto del host remoto

WordToStr (remotePort, dyna + 16);
dyna [21] = '[';
WordToStr (destPort, dyna + 22);
dyna [27] = ']';
dyna [28] = 0;
// la longitud total de la solicitud es la longitud de la cadena

dinámica más el texto de la solicitud
len = 28 + reqLength;
// pone la cadena dinámica en el búfer de transmisión

Ethernet_putBytes (dyna, 28);
// luego coloca la cadena de solicitud convertida en char superior

en el búfer de transmisión
while (reqLength--)
{
Ethernet_putByte (toupper (Ethernet_getByte ()));
}
retorno (len); // volver a la biblioteca con la longitud

de la respuesta UDP
}
/ *
* Entrada principal
* /
void main ()
{
ADCON1 = 0x0B; // los convertidores ADC se utilizarán con
AN2 y AN3
CMCON = 0x07; // apagar los comparadores
PORTA = 0;
TRISA = 0xfc; // establezca PORTA como entrada para ADC
// excepto RA0 y RA1 que se utilizarán
como
// LEDA y LEDB de Ethernet
PORTB = 0;
TRISB = 0xff; // establece PORTB como entrada para los
botones
PORTD = 0;
TRISD = 0; // establece PORTD como salida
/ *
* Inicializar el controlador de Ethernet
* /
Ethernet_Init (myMacAddr, myIpAddr, Ethernet_FULLDUPLEX);
// dhcp no se usará aquí, así que use direcciones preconfiguradas

Ethernet_confNetwork (ipMask, gwIpAddr, dnsIpAddr);
while (1) // hacer para siempre

{
/ *
* Si es necesario, prueba el valor de retorno para
obtener el código de error
* /
Ethernet_doPacket (); // procesar los paquetes entrantes
de Ethernet
/ *
* agrega tus cosas aquí si es necesario
* Ethernet_doPacket () debe llamarse tan a menudo como
sea posible
* de lo contrario los paquetes podrían perderse
* /
}
}
Biblioteca de memoria flash

Esta biblioteca proporciona rutinas para acceder a la memoria Flash del
microcontrolador. Tenga en cuenta que los prototipos difieren para las familias
PIC16 y PIC18.
Importante: Debido a las características específicas de la familia P16 / P18,

la biblioteca de flash depende de la MCU. Dado que la familia P18 difiere
significativamente en el número de bytes que se pueden borrar y / o escribir en
MCU específicas, el sufijo apropiado se agrega a los nombres de las funciones para
facilitar su uso.
Las operaciones de memoria flash son dependientes de MCU:
1. Operación de lectura soportada. Para este grupo de MCU solo se
implementa la función de lectura.
2. Operaciones de lectura y escritura compatibles (la escritura se
ejecuta como borrado y escritura). Para este grupo de MCU se
implementan las funciones de lectura y escritura. Tenga en cuenta que
la operación de escritura que se ejecuta como borrado y escritura,
puede escribir menos bytes de los que borra.
3. Operaciones de lectura , escritura y borrado soportadas. Para este
grupo de MCU se implementan las funciones de lectura, escritura y
borrado. Además, el bloque de memoria flash debe borrarse antes de
escribir (la operación de escritura no se ejecuta como borrado y
escritura).
Consulte la hoja de datos de MCU antes de usar la biblioteca flash.
 FLASH_Leer
 FLASH_Read_N_Bytes
 FLASH_Write
 FLASH_Write_8
 FLASH_Write_16
 FLASH_Write_32
 FLASH_Write_64
 FLASH_Erase
 FLASH_Erase_64
 FLASH_Erase_1024
 FLASH_Erase_Write
 FLASH_Erase_Write_64
 FLASH_Erase_Write_1024
FLASH_Leer
sin firmar FLASH_Read ( dirección sin firmar );
// para PIC18
sin firma FLASH_Read ( dirección larga );
Devoluciones Devuelve el byte de datos de la memoria flash.

Descripción Lee los datos de la especificada addressen la memoria
Flash.
Requiere Nada.
Ejemplo // para PIC18

sin firmar tmp corto ;
...
tmp = FLASH_Read (0x0D00);
...
FLASH_Read_N_Bytes
Prototipo void FLASH_Read_N_Bytes ( dirección larga , char
* data_, unsigned int N);
Devoluciones Nada.
Descripción Lee datos N de los especificados addressen la memoria

Flash a varibale apuntado pordata
Requiere Nada.
Ejemplo FLASH_Read_N (0x0D00, data_buffer, sizeof

(data_buffer));
FLASH_Write
vacío FLASH_Write ( sin signo
de dirección, unsigned int datos *);
// para PIC18
void FLASH_Write_8 ( dirección larga , datos * );
Devoluciones Nada.
Descripción Escribe bloque de datos en la memoria flash. El tamaño del

bloque es dependiente de MCU.
P16: esta función puede borrar el segmento de memoria
antes de escribirle un bloque de datos (depende de
MCU). Además, el segmento de memoria que se borrará
puede ser mayor que el tamaño del bloque de datos que se
escribirá (depende de MCU). Por lo tanto, se recomienda
escribir tantos bytes como borre. FLASH_Write escribe 4
ubicaciones de memoria flash en una fila, por lo que debe
llamarse tantas veces como sea necesario para cumplir con
el tamaño del bloque de datos que se escribirá.
P18: Esta función no realiza borrado antes de escribir.
Requiere Es posible que la memoria flash que se escribirá deba

borrarse antes de llamar a esta función (depende de
MCU). Consulte la hoja de datos de MCU para más detalles.
Ejemplo Escriba valores consecutivos en 64 ubicaciones
consecutivas, comenzando desde 0x0D00:
sin firmar corta para escribir [64];
...
// inicializar matriz:
para (i = 0; i <64; i ++)
para escribir [i] = i;
// escribe el contenido de la matriz en la dirección

0x0D00:
FLASH_Write_64 (0x0D00, toWrite);
FLASH_Erase
void FLASH_Erase ( dirección sin firmar );
// para PIC18
void FLASH_Erase_64 ( dirección larga );
void FLASH_Erase_1024 ( dirección larga );
Devoluciones Nada.
Descripción Borra el bloque de memoria a partir de una dirección

dada. Para P16, familly se implementa solo para aquellas
MCU cuya memoria flash no admite operaciones de borrado
y escritura (consulte la hoja de datos para obtener más
información).
Requiere Nada.
Ejemplo Borre el bloque de memoria de 64 bytes, comenzando

desde la dirección 0x0D00:
FLASH_Erase_64 (0x0D00);
FLASH_Erase_Write
void FLASH_Erase_Write_64 ( dirección larga ,
datos *);
void FLASH_Erase_Write_1024 ( dirección larga ,
char * datos);
Devoluciones Ninguna.
Descripción Borre y escriba el bloque de memoria a partir de una

dirección dada.
Requiere Nada.
Ejemplo char toWrite [64];

int i;
...
// inicializar matriz:
para (i = 0; i <64; i ++) toWrite [i] = i;
// borra el bloque de memoria en la dirección 0x0D00

y luego escribe el contenido de la matriz en la
dirección 0x0D00:
FLASH_Erase_Write_64 (0x0D00, toWrite);
El ejemplo muestra la escritura simple en la memoria flash para PIC16F887, luego
lee los datos y los muestra en PORTB y PORTC.
char i = 0;
unsigned int addr, data_, dataAR [4] [4] = {{0x3FAA + 0, 0x3FAA + 1,
0x3FAA + 2, 0x3FAA + 3},
{0x3FAA + 4, 0x3FAA + 5, 0x3FAA
+ 6, 0x3FAA + 7},
{0x3FAA + 8, 0x3FAA + 9, 0x3FAA
+ 10, 0x3FAA + 11},
{0x3FAA + 12, 0x3FAA + 13,
0x3FAA + 14, 0x3FAA + 15}};
void main () {
ANSEL = 0; // Configurar AN pins como digitales
ANSELH = 0;
C2ON_bit = 0;
PORTB = 0; // Valor PORTB inicial TRISB
= 0; // Establecer PORTB como salida
PORTC = 0; // Valor PORTC inicial
TRISC = 0; // Establecer PORTC como salida
Delay_ms (500);
// Todas las escrituras de bloque

// en la memoria del programa se realizan como borrado de 16 palabras
mediante
// operaciones de escritura de ocho palabras. La operación de escritura
está
// alineada al borde y no puede ocurrir a través de los límites.
// Por lo tanto, se recomienda realizar escrituras flash en fragmentos
de 16 palabras.
// Es por eso que los 4 bits inferiores de la dirección de inicio [3: 0]
deben ser cero.
// Dado que la rutina FLASH_Write realiza escrituras en fragmentos de 4
palabras,
// necesitamos llamarla 4 veces seguidas.
addr = 0x0430; // dirección Flash inicial, válida
para P16F887
para (i = 0; i <4; i ++) { // Escriba algunos datos en Flash
Delay_ms (100);
FLASH_Write (addr + i * 4, dataAR [i]);
}
Delay_ms (500);
addr = 0x0430;
para (i = 0; i <16; i ++) {
data_ = FLASH_Read (addr ++); // El FLASH de P16 es de 14 bits
de ancho, por lo que
Delay_us (10); // dos MSB siempre serán '00'
PORTB = data_; // Mostrar datos en PORTB (LS Byte)
PORTC = data_ >> 8; // y PORTC (MS Byte)
Delay_ms (500);
}
}
Biblioteca Lcd Gráfica
El mikroC PRO para PIC proporciona una biblioteca para operar Graphic Lcd 128x64
(con el controlador Samsung KS108 / KS107 comúnmente usado).
Para crear un conjunto personalizado de imágenes Glcd use la herramienta Editor
de mapa de bits de Glcd .
Importante: la familia de MCU PIC16 no admite trabajar con recursos

externos.
Dependencias externas de Graphic Lcd Library.

Las siguientes
variables deben
Descripción
:
proyectos usando
Graphic Lcd Library:
Puerto de
extern sfr
charGLCD_DataPort; datos de char GLCD_DataPort at PORTD;
Glcd.
Chip de
extern sfr
sbit GLCD_CS1; selección de sbit GLCD_CS1 atRB0_bit;
1 línea.
Chip de
extern sfr
sbit GLCD_CS2; selección de sbit GLCD_CS2 atRB1_bit;
2 líneas.
Registrar
extern sfr
sbit GLCD_RS; línea de sbit GLCD_RS atRB2_bit;
selección.
Línea de
extern sfr
sbit GLCD_RW; lectura / sbit GLCD_RW atRB3_bit;
escritura.
extern sfr Habilitar sbit GLCD_EN atRB4_bit;
sbit GLCD_EN; línea.
extern sfr Restablecer sbit GLCD_RST atRB5_bit;
sbit GLCD_RST; línea.
sbitGLCD_CS1_Direction at TRISB0_b
sbitGLCD_CS1_Directio Chip Select it;
n; 1 pin.

sbitGLCD_CS2_Direction at TRISB1_b
sbitGLCD_CS2_Directio Chip Select it;
n; 2 pin.
Dirección del
extern sfr
sbitGLCD_RS_Direction registro sbitGLCD_RS_Direction at TRISB2_bi
; seleccionar t;
pin.
extern sfr
sbitGLCD_RW_Direction Dirección del sbitGLCD_RW_Direction at TRISB3_bi
; pin de t;
lectura /
escritura.
extern sfr
sbitGLCD_EN_Direction Dirección del sbitGLCD_EN_Direction at TRISB4_bi
; pin Habilitar. t;

sbitGLCD_RST_Direction at TRISB5_b
sbitGLCD_RST_Directio pin de it;
n; reinicio.
Rutinas básicas:
 Glcd_Init
 Glcd_Set_Side
 Glcd_Set_X
 Glcd_Set_Page
 Glcd_Read_Data
 Glcd_Write_Data
 Glcd_Set_Ext_Buffer
Rutinas avanzadas:
 Glcd_Fill
 Glcd_Dot
 Glcd_Line
 Glcd_V_Line
 Glcd_H_Line
 Glcd_Rectangle
 Glcd_Rectangle_Round_Edges
 Glcd_Rectangle_Round_Edges_Fill
 Glcd_Box
 Glcd_Circle
 Glcd_Circle_Fill
 Glcd_Set_Font
 Glcd_Set_Font_Adv
 Glcd_Set_Ext_Font_Adv
 Glcd_Write_Char
 Glcd_Write_Char_Adv
 Glcd_Write_Text
 Glcd_Write_Text_Adv
 Glcd_Write_Const_Text_Adv
 Glcd_Image
 Glcd_Ext_Image
 Glcd_PartialImage
 Glcd_Ext_PartialImage
Glcd_Init
Prototipo void Glcd_Init ();
Devoluciones Nada.
Descripción Inicializa el módulo Glcd. Cada una de las líneas de control

puede configurarse tanto en el puerto como en el pin,
mientras que las líneas de datos deben estar en un solo
puerto (pines <0: 7>).

 GLCD_CS1 : Chip select 1 pin de señal
 GLCD_CS2 : Chip select 2 pin de señal
 GLCD_RS : Registrar pin de señal de selección
 GLCD_RW : Pin de señal de lectura / escritura
 GLCD_EN : Habilitar pin de señal
 GLCD_RST : Restablecer pin de señal
 GLCD_DataPort : Puerto de datos
 GLCD_CS1_Direction : Dirección del chip select

1 pin.
 GLCD_CS2_Direction : Dirección del chip select
2 pin.
 GLCD_RS_Direction : Dirección del pin de señal
de selección de registro.
 GLCD_RW_Direction : Dirección del pin de señal
de lectura / escritura
 GLCD_EN_Direction : Dirección del pin de señal
de habilitación
 GLCD_RST_Direction : Dirección del pin de
señal de reinicio
Ejemplo // configuración de pines glcd

char GLCD_DataPort en PORTD;
sbit GLCD_CS1 en RB0_bit;

sbit GLCD_RS en RB2_bit;
sbit GLCD_RW en RB3_bit;
sbit GLCD_EN en RB4_bit;
sbit GLCD_RST en RB5_bit;
sbit GLCD_CS1_Direction at TRISB0_bit;

sbit GLCD_RS_Direction at TRISB2_bit;
sbit GLCD_RW_Direction at TRISB3_bit;
sbit GLCD_EN_Direction at TRISB4_bit;
sbit GLCD_RST_Direction at TRISB5_bit;
...
ANSEL = 0;
ANSELH = 0;
Glcd_Init ();
Glcd_Set_Side
Prototipo void Glcd_Set_Side ( sin signo corto x_pos);
Devoluciones Nada.
Descripción Selecciona el lado Glcd. Consulte la hoja de datos de Glcd

para una explicación detallada.
Parámetros:
 x_pos:posición en el eje x. Valores válidos:
0..127
El parámetro x_posespecifica el lado de Glcd: los valores de
0 a 63 especifican el lado izquierdo, los valores de 64 a
127 especifican el lado derecho.
Nota: Para la explicación del lado, eje x y diseño de
página, vea el esquema al final de esta página.
Requiere Glcd necesita ser inicializado, vea la rutina Glcd_Init .
Ejemplo Las siguientes dos líneas son equivalentes, y ambas

seleccionan el lado izquierdo de Glcd:
Glcd_Select_Side (0);
Glcd_Select_Side (10);
Glcd_Set_X
Prototipo void Glcd_Set_X ( sin signo x_pos cortos );
Devoluciones Nada.
Descripción Establece la posición del eje x en x_pospuntos desde el

borde izquierdo de Glcd dentro del lado seleccionado.
Parámetros:
0..63

Ejemplo Glcd_Set_X (25);
Glcd_Set_Page
Prototipo void Glcd_Set_Page ( página corta sin firmar );
Devoluciones Nada.
Descripción Selecciona la página del Glcd.

Parámetros:
 page:número de página. Valores válidos: 0..7

Ejemplo Glcd_Set_Page (5);
Glcd_Read_Data
Prototipo Glcd_Read_Data () corto sin firmar ;
Devoluciones Un byte de la memoria Glcd.
Descripción Lee datos de la ubicación actual de la memoria de Glcd y

se mueve a la siguiente ubicación.
El lado de Glcd, la posición del eje x y la página deben
configurarse primero. Consulte las
funciones Glcd_Set_Side , Glcd_Set_X y Glcd_Set_Page .
Ejemplo datos cortos sin firmar ;

...
datos = Glcd_Read_Data ();
Glcd_Write_Data
Prototipo void Glcd_Write_Data ( ddata corto sin firmar);
Devoluciones Nada.
Descripción Escribe un byte a la ubicación actual en la memoria Glcd y

se mueve a la siguiente ubicación.
Parámetros:
 ddata: datos a escribir

funciones Glcd_Set_Side , Glcd_Set_X y Glcd_Set_Page .
Ejemplo datos cortos sin firmar;

...
Glcd_Write_Data (data_);
Glcd_Set_Ext_Buffer
Prototipo void Glcd_Set_Ext_Buffer (char * (* getExtDataPtr)
( desplazamiento largo sin signo , cuenta int
sin signo , int * num sin signo ));
Devoluciones Nada.
Descripción La función establece el puntero a la función de usuario que

manipula el recurso externo.
Parámetros:
 offset - desplazamiento desde el principio del
recurso desde donde se solicitan los datos.
 count - Número solicitado de bytes.
 num - variable para mantener el número
devuelto ob byte (menor o igual que el número
de bytes conectados).

la rutina Glcd_Init .
Ejemplo char * ReadExternalBuffer ( offset largo sin signo ,

cuenta int sin signo , int * num sin signo ) {
uns_sector long start sin signo;
unsigned int pos;
start_sector = Mmc_Get_File_Write_Sector () +
offset / 512;
pos = ( sin signo largo ) offset% 512;
if (start_sector == currentSector + 1) {
Mmc_Multi_Read_Buffer (EXT_BUFFER);
currentSector = start_sector;
} else
if (start_sector! = currentSector) {
Mmc_Multi_Read_Stop ();
Mmc_Multi_Read_Start (start_sector);
}
si (cuenta> 512-pos) {
* num = 512-pos;
}
más
* num = cuenta;
devuelve EXT_BUFFER + pos;

}
Glcd_Set_Ext_Buffer (ReadExternalBuffer);
Glcd_Fill
Prototipo void Glcd_Fill ( patrón corto sin firmar );
Devoluciones Nada.
Descripción Llena la memoria Glcd con el byte pattern.

Parámetros:
 pattern: byte para llenar la memoria Glcd con
Para borrar la pantalla de Glcd, use Glcd_Fill(0).
Para llenar la pantalla completamente,
use Glcd_Fill(0xFF).
Ejemplo // Borrar pantalla

Glcd_Fill (0);
Glcd_Dot
Prototipo void Glcd_Dot ( sin signo corto x_pos, sin signo
corto y_pos, sin signo corto color);
Devoluciones Nada.
Descripción Dibuja un punto en Glcd en las coordenadas

( x_pos, y_pos).
Parámetros:
 x_pos:posición x Valores válidos: 0..127
 y_pos:posición y Valores válidos: 0..63
 color:parámetro de color Valores válidos: 0..2
El parámetro colordetermina un estado de punto: 0 borra
el punto, 1 pone un punto y 2 invierte el estado del punto.
Nota: Para la explicación del diseño de los ejes x e y,

vea el esquema al final de esta página.
Ejemplo // Invertir el punto en la esquina superior

izquierda
Glcd_Dot (0, 0, 2);
Glcd_Line
Prototipo void Glcd_Line
( int x_start, int y_start, int x_end, int y_end, co
lor corto sin signo );
Devolucion Nada.
es
Descripció Dibuja una línea en Glcd.

n Parámetros:
 x_start:Coordenada x de la línea de
inicio. Valores válidos: 0..127
 y_start:Coordenada y de la línea de
 x_end:Coordenada x del final de la línea. Valores
válidos: 0..127
 y_end:Coordenada y del final de la línea. Valores
válidos: 0..63
El parámetro colordetermina el color de la línea: 0 blanco, 1
negro y 2 invierte cada punto.
Ejemplo // Dibuja una línea entre los puntos (0,0) y (20,30)

Glcd_Line (0, 0, 20, 30, 1);
Glcd_V_Line
Prototipo void Glcd_V_Line ( short y_start sin signo,
y_end short y sinsigno, x_pos cortos
sin firmar , color corto sin firmar );
Devoluciones Nada.
Descripción Dibuja una línea vertical en Glcd.

Parámetros:
 y_end:Coordenada y del final de la
línea. Valores válidos: 0..63
 x_pos:coordenada x de linea vertical. Valores
válidos: 0..127
El parámetro colordetermina el color de la línea: 0 blanco,
1 negro y 2 invierte cada punto.
Ejemplo // Dibuja una línea vertical entre los puntos (10,5)

y (10,25)
Glcd_V_Line (5, 25, 10, 1);
Glcd_H_Line
Prototipo void Glcd_H_Line ( corto sin signo x_start, corto
sin signo x_end, cortos sin signo y_pos, corto sin
signo de color);
Devoluciones Nada.
Descripción Dibuja una línea horizontal en Glcd.

Parámetros:
 x_end:Coordenada x del final de la
 y_pos:y coordenada de linea
horizontal. Valores válidos: 0..63
Ejemplo // Dibuja una línea horizontal entre los puntos

(10,20) y (50,20)
Glcd_H_Line (10, 50, 20, 1);
Glcd_Rectangle
Prototipo void Glcd_Rectangle ( sin signo x_upper_left, sin
signoy_upper_left, sin signo x_bottom_right, sin
signo y_bottom_right, sin color);
Devoluciones Nada.

Parámetros:
 x_upper_left:Coordenada x de la esquina
superior izquierda del rectángulo. Valores
válidos: 0..127
 y_upper_left:Coordenada y de la esquina
válidos: 0..63
 x_bottom_right:Coordenada x de la esquina
inferior derecha del rectángulo. Valores válidos:
0..127
 y_bottom_right:Coordenada y de la esquina
0..63
El parámetro colordetermina el color del borde del
rectángulo: 0 blanco, 1 negro y 2 invierte cada punto.
Ejemplo // Dibuja un rectángulo entre los puntos (5,5) y

(40,40)
Glcd_Rectangle (5, 5, 40, 40, 1);
Glcd_Rectangle_Round_Edges
Prototipo void Glcd_Rectangle_Round_Edges ( sin signo
corto x_upper_left, sin signo
corto y_upper_left, sin signo
cortox_bottom_right, sin signo
corto y_bottom_right, sin
signo round_radius corto , sin
signo color corto );
Devoluciones Nada.

Parámetros:
válidos: 0..127
válidos: 0..63
0..127
0..63
Ejemplo // Dibuje un rectángulo de borde redondeado entre

los puntos (5,5) y (40,40) con el radio de 12
Glcd_Rectangle_Round_Edges (5, 5, 40, 40, 12, 1);
Glcd_Rectangle_Round_Edges_Fill
Prototipo void Glcd_Rectangle_Round_Edges_Fill ( sin signo
corto y_bottom_right, sin signo redondo
corto_radio, sin signo de color corto );
Devoluciones Nada.
Descripción Dibuja un borde de borde redondeado relleno en Glcd con

color.
Parámetros:
válidos: 0..127
válidos: 0..63
0..127
0..63
 round_radius: radio del borde redondeado
Ejemplo // Dibuja un rectángulo de borde redondeado relleno

entre los puntos (5,5) y (40,40) con el radio de 12
Glcd_Rectangle_Round_Edges_Fill (5, 5, 40, 40, 12,
1);
Glcd_Box
Prototipo void Glcd_Box ( sin signo x_upper_left corto , sin
signoy_upper_left, sin
signo x_bottom_right corto , sin
signoy_bottom_right corto , sin
firmar color corto );
Devoluciones Nada.
Descripción Dibuja una caja en Glcd.

Parámetros:
superior izquierda del cuadro. Valores válidos:
0..127
superior izquierda del cuadro. Valores válidos:
0..63
inferior derecha del cuadro. Valores válidos:
0..127
inferior derecha del cuadro. Valores válidos:
0..63
El parámetro colordetermina el color del relleno del
cuadro: 0 blanco, 1 negro y 2 invierte cada punto.
Ejemplo // Dibuja un cuadro entre los puntos (5,15) y

(20,40)
Glcd_Box (5, 15, 20, 40, 1);
Glcd_Circle
Prototipo void Glcd_Circle
( int x_center, int y_center, int radio, unsigned
short color);
Devoluciones Nada.

Parámetros:
 x_center:Coordenada x del centro del
círculo. Valores válidos: 0..127
 y_center:Y coordenada del centro del
 radius: tamaño del radio
El parámetro colordetermina el color de la línea circular: 0
blanco, 1 negro y 2 invierte cada punto.
Ejemplo // Dibuja un círculo con centro en (50,50) y radio =

10
Glcd_Circle (50, 50, 10, 1);
Glcd_Circle_Fill
Prototipo void Glcd_Circle_Fill
( int x_center, int y_center, int radio, color cor
to sin signo );
Devolucione Nada.
s

Parámetros:
Ejemplo // Dibuja un círculo relleno con centro en (50,50) y

radio = 10
Glcd_Circle_Fill (50, 50, 10, 1);
Glcd_Set_Font
Prototipo void Glcd_Set_Font ( const char *
activeFont, unsigned short aFontWidth, unsigned
short aFontHeight, unsigned int aFontOffs);
Devoluciones Nada.
Descripción Establece la fuente que se utilizará con

las rutinas Glcd_Write_Char y Glcd_Write_Text .
Parámetros:
 activeFont:fuente a configurar. Necesita ser
formateado como una matriz de caracteres.
 aFontWidth: ancho de los caracteres de la
fuente en puntos.
 aFontHeight: Altura de los caracteres
tipográficos en puntos.
 aFontOffs:número que representa la diferencia
entre el conjunto de caracteres mikroC PRO for
PIC y el conjunto ASCII regular (por ejemplo, si
'A' es 65 en el carácter ASCII, y 'A' es 45 en el
conjunto de caracteres mikroC PRO for PIC,
aFontOffs es 20). Las fuentes de demostración
suministradas con la biblioteca tienen un
desplazamiento de 32, lo que significa que
comienzan con espacio.
El usuario puede usar las fuentes proporcionadas en el
archivo "__Lib_GLCDFonts" ubicado en la carpeta Usos o
crear sus propias fuentes.
Lista de fuentes soportadas:
 Font_Glcd_System3x5
 Font_Glcd_5x7
 Font_Glcd_Character8x7
Por el bien de la compatibilidad con versiones anteriores,
estas fuentes también son compatibles:
 System3x5(equivalente a Font_Glcd_System3x5)
 FontSystem5x7_v2(equivalente
a Font_Glcd_System5x7)
 font5x7(equivalente a Font_Glcd_5x7)
 Character8x7(equivalente
a Font_Glcd_Character8x7)
Ejemplo // Use la fuente 5x7 personalizada "myfont" que

comienza con el espacio (32):
Glcd_Set_Font (& myfont, 5, 7, 32);
Glcd_Set_Font_Adv
Prototipo void Glcd_Set_Font_Adv ( const far char *
activeFont, unsigned
charfont_color, char font_orientation);

las rutinas Glcd_Write_Char_Adv y Glcd_Write_Text_Adv .
Parámetros  activeFont:fuente a configurar. Necesita ser

 font_color: Establece el color de la fuente.
 font_orientation: Establece la orientación de
la fuente.
Devoluciones Nada.
Ejemplo Glcd_Set_Font_Adv (& myfont, 0, 0);
Notas Ninguna.
Glcd_Set_Ext_Font_Adv
Prototipo void Glcd_Set_Ext_Font_Adv ( sin signo
long activeFont, unsigned
int font_color, char font_orientation);

las rutinas Glcd_Write_Char_Adv y Glcd_Write_Text_Adv .
La fuente se encuentra en un recurso externo.
Parámetros  activeFont:fuente a configurar. Este

parámetro representa la dirección en el recurso
externo desde donde comienzan los datos de la
fuente.
 font_orientation: Establece la orientación de
la fuente.
Devolucione Nada.
s
Ejemplo Glcd_Set_Ext_Font_Adv (173296, 5, 7, 32);

Notas Ninguna.
Glcd_Write_Char
Prototipo anular Glcd_Write_Char ( unsigned
short chr, cortos sin signo x_pos, corto sin
signo page_num, corto sin signo de color);
Devoluciones Nada.
Descripción Imprime personaje en el Glcd.

Parámetros:
 chr: personaje para ser escrito
 x_pos:Posición inicial del personaje en el eje
x. Valores válidos: 0 .. (127-FontWidth)
 page_num:el número de la página en la que se
escribirá el carácter. Valores válidos: 0..7
El parámetro colordetermina el color del carácter: 0
Nota: para el eje x y la explicación del diseño de la

Requiere Glcd necesita ser inicializado, vea

la rutina Glcd_Init . Use Glcd_Set_Font para especificar la
fuente para mostrar; si no se especifica ninguna
fuente, Font_Glcd_System5x7se utilizará la
fuente predeterminada que se suministra con la biblioteca.
Ejemplo // Escriba el carácter 'C' en la posición 10 dentro

de la página 2:
Glcd_Write_Char ('C', 10, 2, 1);
Glcd_Write_Char_Adv
Prototipo void Glcd_Write_Char_Adv ( carácter
sin signo , int sin signo , sin signo y);
Devoluciones Nada.
Descripción Escribe un char en el glcd en las coordenadas (x, y).

 ch: char para ser escrito.
 x: Posición char en el eje x.
 y: Posición char en el eje y.
Requiere El módulo glcd necesita ser inicializado. Ver

Ejemplo Glcd_Write_Char_Adv ('A', 22,23);
Glcd_Write_Text
Prototipo vacío Glcd_Write_Text ( Char * texto, cortos sin
signo x_pos, corto sin signopage_num, corto sin
signo de color);
Devoluciones Nada.
Descripción Imprime texto en Glcd.

Parámetros:
 text: texto para ser escrito
 x_pos: Posición inicial del texto en el eje x.
 page_num:El número de la página en la que se
escribirá el texto. Valores válidos: 0..7
El parámetro colordetermina el color del texto: 0 blanco, 1
Nota: para el eje x y la explicación del diseño de la

Requiere Glcd necesita ser inicializado, vea

la rutina Glcd_Init . Use Glcd_Set_Font para especificar la
fuente para mostrar; si no se especifica ninguna
fuente, Font_Glcd_System5x7se utilizará la
fuente predeterminada que se suministra con la biblioteca.
Ejemplo // Escribir texto "¡Hola mundo!" en la posición 10

dentro de la página 2:
Glcd_Write_Text ("¡Hola mundo!", 10, 2, 1);
Glcd_Write_Text_Adv
Prototipo void Glcd_Write_Text_Adv ( unsigned char *
text, unsigned int x, unsigned int y);
Devoluciones Nada.
Descripción Escribe texto en el glcd en coordenadas (x, y).

Parámetros:
 text: Texto a escribir.
 x: Posición del texto en el eje x.
 y: Posición del texto en el eje y.

Ejemplo Glcd_Write_Text_Adv ("GLCD LIBRARY DEMO, WELCOME!",

0, 0);
Glcd_Write_Const_Text_Adv
Prototipo void Glcd_Write_Const_Text_Adv ( const far char *
ctext, unsigned int x, unsigned int y);
Devoluciones Nada.
Descripción Escribe el texto ubicado en la memoria del programa en el
glcd en las coordenadas (x, y).
Parámetros:

Ejemplo const ctext [] = "mikroElektronika";

...
Glcd_Write_Const_Text_Adv (ctext, 0, 0);
Glcd_Image
Prototipo void Glcd_Image ( code const unsigned short *
image);
Devoluciones Nada.

Parámetros:
de bits debe estar ubicada en la memoria de
código.
Utilice el Editor de mapas de bits de Glcd integrado
de mikroC PRO for PIC para convertir la imagen a una
matriz constante adecuada para mostrar en Glcd.
Ejemplo // Dibuja la imagen mi_imagen en Glcd

Glcd_Image (mi_imagen);
Glcd_Ext_Image
Prototipo void Glcd_Ext_Image ( imagen larga sin firmar );
Descripción Muestra un mapa de bits de un recurso externo.
Parámetros  image:Imagen a mostrar. Este parámetro

representa la dirección en el recurso externo
desde donde comienzan los datos de la
imagen.
Devoluciones Nada.
Ejemplo Glcd_Ext_Image (153608);

Notas Utilice el mikroC PRO para el editor de mapas de bits de
Glcd integrado en PIC32, Herramientas > Editor de
mapas de bits de Glcd , para convertir la imagen en una
Glcd_PartialImage
Prototipo void Glcd_PartialImage ( sin signo int x_left, sin
signo int y_top, sin signo int ancho, sin signo
int alto, sin signo int picture_width, sin signo
imagen);
Devoluciones Nada.

deseada.
Parámetros:
Use el Editor de mapa de bits de Glcd (opción de
menú Herramientas ›Editor de mapa de bits de Glcd )
para convertir la imagen a una matriz constante adecuada
para mostrar en Glcd.

Glcd_PartialImage (10, 12, 10, 15, 16, 32, imagen);
Glcd_Ext_PartialImage
Prototipo void Glcd_Ext_PartialImage ( sin signo
int x_left, sin signo inty_top, sin signo
intpicture_width, sin signo
int picture_height, sin signo largaimagen);
Descripción Muestra un área parcial de la imagen, ubicada en un

recurso externo, en una ubicación deseada de la pantalla.
Parámetros  x_left: Coordenada x de la ubicación deseada

 image:Imagen a mostrar. Este parámetro
imagen.
Devoluciones Nada.
Ejemplo Glcd_Ext_PartialImage (10, 12, 10, 15, 16, 32, 0);
Notas Utilice el mikroC PRO para el editor de mapas de bits de

Glcd integrado en PIC32, Herramientas > Editor de
mapas de bits de Glcd , para convertir la imagen en una
El siguiente ejemplo muestra las rutinas de la biblioteca Glcd: inicialización, borrado
(relleno de patrón), visualización de imágenes, dibujo de líneas, círculos, cuadros y
rectángulos, visualización y manejo de texto.
// Declaraciones ----------------------------------------------- ---------

----------
const code char truck_bmp [1024];
// ------------------------------------------------ --------------
declaraciones finales
// Conexiones del módulo Glcd



// Terminar las conexiones del módulo Glcd
void delay2S () { // 2 segundos de

retraso de la función
Delay_ms (2000);
}
void main () {
unsigned short ii;
char * someText;
#define COMPLETE_EXAMPLE // comente esta línea
para simplificar /
reducir el ejemplo ANSEL = 0; //
Configurar AN pins como digitales
ANSELH = 0;
C1ON_bit = 0; // Desactivar
comparadores
C2ON_bit = 0;
Glcd_Init (); // Inicializar

GLCD Glcd_Fill (0x00); // Borrar GLCD
mientras (1) {
Glcd_Image (truck_bmp); // dibujar imagen
delay2S (); delay2S ();
#terminara si
Glcd_Fill (0x00); // Borrar GLCD
Glcd_Box (62,40,124,56,1); // Dibujar caja

Glcd_Rectangle (5,5,84,35,1); // Dibujar rectángulo
Glcd_Line (0, 0, 127, 63, 1); // Dibujar linea
delay2S ();
para (ii = 5; ii <60; ii + = 5) { // Dibuja líneas

horizontales y verticales
Delay_ms (250);
Glcd_V_Line (2, 54, ii, 1);
Glcd_H_Line (2, 120, ii, 1);
}
delay2S ();
Glcd_Fill (0x00); // Borrar GLCD

Glcd_Set_Font (Font_Glcd_Character8x7, 8, 7, 32); // Elija la
fuente, vea __Lib_GLCDFonts.c en la carpeta Usos
#terminara si
Glcd_Write_Text ("mikroE", 1, 7, 2); // escribir
cadena
para (ii = 1; ii <= 10; ii ++) // Dibujar

círculos
Glcd_Circle (63,32, 3 * ii, 1);
delay2S ();
Glcd_Box (12,20, 70,57, 2); // dibujar

caja
delay2S ();
Glcd_Fill (0xFF); // Rellena
GLCD
Glcd_Set_Font (Font_Glcd_Character8x7, 8, 7, 32); // Cambiar

fuente
someText = "8x7 Font";
Glcd_Write_Text (someText, 5, 0, 2); // escribir
cadena
delay2S ();
Glcd_Set_Font (Font_Glcd_System3x5, 3, 5, 32); // Cambiar
fuente
someText = "SÓLO CAPITALS 3X5";
cadena
delay2S ();
Glcd_Set_Font (Font_Glcd_System5x7, 5, 7, 32); // Cambiar

fuente
cadena
delay2S ();
Glcd_Set_Font (Font_Glcd_5x7, 5, 7, 32); // Cambiar

fuente
someText = "5x7 Font (v2)";
cadena
delay2S ();
#terminara si
}
}
Conexión HW
Conexión Glcd HW
Biblioteca I²C
El módulo MSSP maestro completo I²C está disponible con varios modelos PIC
MCU. mikroC PRO para PIC proporciona una biblioteca que admite
el modo maestro I²C .
Importante:
 Algunas MCU tienen múltiples módulos I²C . Para utilizar la rutina de
biblioteca I²Cdeseada , simplemente cambie el número 1en el prototipo
con el número de módulo apropiado, es decirI2C2_Init(100000);
 I2C1_Init
 I2C1_Start
 I2C1_Repeated_Start
 I2C1_Is_Idle
 I2C1_Rd
 I2C1_Wr
 I2C1_Stop
I2C1_Init
Prototipo void I2C1_Init ( reloj largo sin
firma constante );
Devoluciones Nada.
Descripción Inicializa I²C con el deseado clock(consulte la hoja de

datos del dispositivo para conocer los valores correctos con
respecto a Fosc ). Debe llamarse antes de usar otras
funciones de la biblioteca I²C .
No es necesario configurar los puertos manualmente para
usar el módulo; La biblioteca se encargará de la
inicialización.
Requiere La biblioteca requiere el módulo MSSP .
Nota: El compilador realiza el cálculo del valor del

reloj I²C, ya que produciría un código relativamente grande
si se realiza en el nivel de la biblioteca. Por lo tanto, el
compilador necesita saber el valor del parámetro en el
tiempo de compilación. Es por eso que este parámetro
debe ser una constante, y no una variable.
Ejemplo I2C1_Init (100000);
I2C1_Start
Prototipo corto sin firmar I2C1_Start ( void );
Devoluciones Si no hay error, la función devuelve 0.
Descripción Determina si el bus I²C está libre y emite la señal de

INICIO.
Requiere I²C debe configurarse antes de usar esta

función. Ver I2C1_Init .
Ejemplo I2C1_Start ();
I2C1_Repeated_Start
Prototipo void I2C1_Repeated_Start ( void );
Devoluciones Nada.
Descripción Problemas repetidos de la señal de inicio.

Ejemplo I2C1_Repeated_Start ();
I2C1_Is_Idle
Prototipo I2C1_Is_Idle ( void ) corto sin firmar ;
Devoluciones Devuelve 1 si el bus I²C está libre, de lo contrario devuelve

0.
Descripción Comprueba si el bus I²C es gratuito.

Ejemplo if (I2C1_Is_Idle ()) {...}
I2C1_Rd
Prototipo I2C1_Rd corto sin firmar (acuse de recibo corto
sin firmar );
Devoluciones Devuelve un byte del esclavo.
Descripción Lee un byte desde el esclavo y envía una señal de no

reconocimiento si el parámetro ackes 0; de lo contrario,
envía un reconocimiento .

Además, la señal de INICIO debe emitirse para poder
utilizar esta función. Ver I2C1_Start .
Ejemplo Leer datos y enviar señal de no reconocimiento :

toma corta sin firmar ;
...
take = I2C1_Rd (0);
I2C1_Wr
Prototipo corto sin firmar I2C1_Wr (datos cortos
sin firmar_);
Devoluciones Devuelve 0 si no hubo errores.
Descripción Envía el byte de datos (parámetro data) a través

del bus I²C .
utilizar esta función. Ver I2C1_Start .
Ejemplo I2C1_Write (0xA3);
I2C1_Stop
Prototipo void I2C1_Stop ( void );
Devoluciones Nada.
Descripción Emite la señal de parada.

Ejemplo I2C1_Stop ();
Este código demuestra el uso de la biblioteca I²C . PIC MCU está conectado (SCL,
pines SDA) a 24c02 EEPROM . El programa envía datos a EEPROM (los datos se
escriben en la dirección 2). Luego, leemos los datos a través de I²C desde EEPROM
y enviamos su valor a PORTB, para verificar si el ciclo fue exitoso (ver la siguiente
figura sobre cómo conectar la interfaz 24c02 con el PIC).
void main () {
ANSEL = 0; // Configurar pines AN como E / S digital
ANSELH = 0;
PORTB = 0;
TRISB = 0; // Configurar PORTB como salida
I2C1_Init (100000); // inicializar la comunicación I2C

I2C1_Start (); // emitir la señal de inicio I2C
I2C1_Wr (0xA2); // enviar byte a través de I2C (dirección
del dispositivo + W)
I2C1_Wr (2); // enviar byte (dirección de la ubicación de
EEPROM)
I2C1_Wr (0xAA); // enviar datos (datos a escribir)
I2C1_Stop (); // emitir señal de parada I2C
Delay_100ms ();
I2C1_Start (); // emitir la señal de inicio I2C

I2C1_Wr (0xA2); // enviar byte a través de I2C (dirección
del dispositivo + W)
I2C1_Wr (2); // enviar byte (dirección de datos)
I2C1_Repeated_Start (); // emitir la señal I2C inicio repetido
I2C1_Wr (0xA3); // enviar byte (dirección del dispositivo +
R)
PORTB = I2C1_Rd (0u); // Leer los datos (sin confirmación)
I2C1_Stop (); // emitir señal de parada I2C
}
Conexión HW
Conexión de 24c02 a PIC a través de I²C
Biblioteca de teclado
El mikroC PRO para PIC proporciona una biblioteca para trabajar con el teclado
4x4. Las rutinas de la biblioteca también se pueden usar con el teclado 4x1, 4x2 o
4x3. Para la explicación de las conexiones, vea el esquema al final de esta página.
Dependencias externas de la biblioteca de teclado
La siguiente
variable debe
definirse en
todos los
Descripción: Ejemplo:
proyectos
usando la
biblioteca del
teclado:
extern sfr Puerto del char keypadPort atPORTD;
charkeypadPort; teclado.
 Keypad_Init
 Keypad_Key_Press
 Teclado_clave_Click
Keypad_Init
Prototipo void Keypad_Init ( void );
Devoluciones Nada.
Descripción Inicializa el puerto para trabajar con el teclado.
Requiere Variable global :

 keypadPort - Puerto del teclado
Ejemplo // Conexiones del módulo de teclado
char keypadPort en PORTD;
// Fin de las conexiones del módulo de teclado.
...
Keypad_Init ();
Keypad_Key_Press
Prototipo char Keypad_Key_Press ( void );
Devoluciones El código de una tecla pulsada (1..16).

Si no se presiona ninguna tecla, devuelve 0.
Descripción Lee la tecla desde el teclado cuando se presiona la tecla.
Requiere El puerto debe inicializarse para trabajar con la biblioteca

del teclado, consulte Keypad_Init .
Ejemplo char kp;

...
kp = Keypad_Key_Press ();
Teclado_clave_Click
Prototipo char Keypad_Key_Click ( void );
Devoluciones El código de una clave pulsada (1..16).

Si no se hace clic en ninguna tecla, devuelve 0.
Descripción La llamada a Keypad_Key_Clickes una llamada de bloqueo:

la función espera hasta que se presiona y suelta alguna
tecla. Cuando se libera, la función devuelve de 1 a 16,
según la clave. Si se presiona más de una tecla
simultáneamente, la función esperará hasta que se liberen
todas las teclas presionadas. Después de eso, la función
devolverá el código de la primera tecla presionada.
Requiere El puerto debe inicializarse para trabajar con la biblioteca

del teclado, consulte Keypad_Init .
Ejemplo char kp;

...
kp = Keypad_Key_Click ();
Este es un ejemplo simple del uso de la biblioteca de teclado. Admite teclados con
1..4 filas y 1..4 columnas. El código que devuelve la función Keypad_Key_Click ()
está en el rango de 1..16. En este ejemplo, el código devuelto se transforma en
códigos ASCII [0..9, A..F] y se muestra en Lcd. Además, se muestra un pequeño
contador de un solo byte en el segundo número de filas Lcd de pulsaciones de
teclas.
kp corto sin firmar , cnt, estado antiguo = 0;

char txt [6];
// Conexiones del módulo de teclado

char keypadPort en PORTD;
// Terminar las conexiones del módulo del teclado
// Conexiones del módulo LCD

sbit LCD_RS en RB4_bit;
sbit LCD_EN en RB5_bit;
sbit LCD_D4 en RB0_bit;
sbit LCD_RS_Direction at TRISB4_bit;

sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
// Terminar las conexiones del módulo LCD
void main () {
cnt = 0; // Restablecer contador
Keypad_Init (); // Inicializar Teclado
ANSEL = 0; // Configurar pines AN como E /
S digital
ANSELH = 0;
Lcd_Init (); // Inicializar LCD
Lcd_Cmd (_LCD_CLEAR); // Borrar pantalla
Lcd_Cmd (_LCD_CURSOR_OFF); // Cursor apagado
Lcd_Out (1, 1, "1");
Lcd_Out (1, 1, "Key:"); // Escribir mensaje de texto en
LCD
Lcd_Out (2, 1, "Times:");
hacer {
kp = 0; // Restablecer la clave del
código variable
// Espere a que se presione y suelte la tecla

do
// kp = Keypad_Key_Press (); // Almacenar código de clave en la
variable
kp kp = Keypad_Key_Click (); // Almacenar el código
clave en la variable kp
while (! Kp);
// Preparar el valor para la salida, transformar la clave en su
interruptor de valor ASCII (kp) {
// caso 10: kp = 42; descanso; // '*' // Descomente este bloque
para keypad4x3
// caso 11: kp = 48; descanso; // '0'
// caso 12: kp = 35; descanso; // '#'
// por defecto: kp + = 48;
caso 1: kp = 49; romper ; // 1 // Descomentar este bloque para

keypad4x4
caso 2: kp = 50; romper ; // 2
caso 4: kp = 65; romper ; // Un
caso 8: kp = 66; romper ; // B
caso 9: kp = 55;romper ; // 7
caso 10: kp = 56; romper ; // 8
caso 11: kp = 57; romper ; // 9
caso 12: kp = 67; romper ; // C
caso 13: kp = 42; romper ; // *
caso 14: kp = 48; romper ; // 0
caso 15: kp = 35; romper ; // #
caso 16: kp = 68; romper ; // D
if (kp! = oldstate) { // La tecla presionada difiere

de la anterior
cnt = 1;
viejo estado = kp;
}
else { // La tecla presionada es
igual que la anterior
cnt ++;
}
Lcd_Chr (1, 10, kp); // Imprimir el valor ASCII

clave en la pantalla LCD
if (cnt == 255) { // Si hay un desbordamiento

variable del contador
cnt = 0;
Lcd_Out (2, 10, "");
}
WordToStr (cnt, txt); // Transformar el valor del

contador en la cadena
Lcd_Out (2, 10, txt); // Mostrar el valor del
contador en la pantalla LCD
} while (1);
}
Conexión HW
Esquema de conexión del teclado 4x4
Biblioteca lcd
El mikroC PRO para PIC proporciona una biblioteca para la comunicación con Lcds
(con controladores compatibles con HD44780) a través de la interfaz de 4 bits. Un
ejemplo de conexiones de Lcd se da en el esquema al final de esta página.
Para crear un conjunto de caracteres Lcd personalizados, use la Herramienta
de caracteres personalizados Lcd .
Dependencias externas de la biblioteca lcd.
Las siguientes
variables deben
Descripción
definirse en todos Ejemplo:
:
los proyectos usando
la Biblioteca Lcd:
Registro
extern sfr
sbit LCD_RS: Seleccionar sbit LCD_RS atRB4_bit;
línea.
extern sfr Habilitar

sbit LCD_EN atRB5_bit;
sbit LCD_EN: línea.
extern sfr Línea de

sbit LCD_D7 atRB3_bit;
sbit LCD_D7; datos 7.



Registro
extern sfr
Seleccionar sbitLCD_RS_Direction at TRISB4_bit
sbitLCD_RS_Direction
; pin de ;
dirección.
extern sfr
Habilitar pin sbitLCD_EN_Direction at TRISB5_bit
sbitLCD_EN_Direction
; de dirección. ;
extern sfr
Dato 7 pin de sbitLCD_D7_Direction at TRISB3_bit
sbitLCD_D7_Direction
; dirección. ;
extern sfr
Data 6 pin de sbitLCD_D6_Direction at TRISB2_bit
; dirección. ;
extern sfr
; dirección. ;
extern sfr
; dirección. ;
 Lcd_Init
 Lcd_Out
 Lcd_Out_Cp
 Lcd_Chr
 Lcd_Chr_Cp
 Lcd_Cmd
Lcd_Init
Prototipo void Lcd_Init ();
Devoluciones Nada.
Descripción Inicializa el módulo lcd.
Requiere Variables globales:

 LCD_D7: Bit de datos 7
 LCD_D6: Bit 6 de datos
 LCD_D5: Bit 5 de datos
 LCD_D4: Bit de datos 4
 LCD_RS: Registro Seleccionar señal (datos /
instrucciones) pin
 LCD_EN: Habilitar pin de señal
 LCD_D7_Direction: Dirección del pin de datos 7

 LCD_D6_Direction: Dirección del dato 6 pin
 LCD_D5_Direction: Dirección del pin Data 5
 LCD_D4_Direction: Dirección del dato 4 pin
 LCD_RS_Direction: Dirección del registro
Seleccionar pin
LCD_EN_Direction: Dirección del pin de señal

de habilitación
Ejemplo // Configuración de pines de Lcd

// Pin direction
...
Lcd_Init ();
Lcd_Out
Prototipo vacío Lcd_Out ( Char fila, carbón columna, Char *
texto);
Devoluciones Nada.
Descripción Imprime texto en Lcd desde la posición especificada. Tanto

las variables de cadena como los literales se pueden pasar
como texto.
Parámetros:
 row: posición inicial número de fila
 column: posición inicial número de columna
Requiere El módulo Lcd necesita ser inicializado. Ver

la rutina Lcd_Init .
Ejemplo // Escribe el texto "¡Hola!" en Lcd a partir de la

fila 1, columna 3:
Lcd_Out (1, 3, "Hello!");
Lcd_Out_Cp
Prototipo void Lcd_Out_Cp ( char * text);
Devoluciones Nada.
Descripción Imprime texto en Lcd en la posición actual del

cursor. Tanto las variables de cadena como los literales se
pueden pasar como texto.
Parámetros:

Ejemplo // Escribir texto "¡Aquí!" en la posición actual del

cursor:
Lcd_Out_Cp ("Here!");
Lcd_Chr
Prototipo void Lcd_Chr
( Char fila, Char columna, Char out_char);
Devoluciones Nada.
Descripción Imprime el carácter en Lcd en la posición
especificada. Tanto las variables como los literales pueden
pasarse como un personaje.
Parámetros:
 row: número de fila de posición de escritura
 column: número de columna de posición de
escritura
 out_char: personaje para ser escrito

Ejemplo // Escriba el carácter "i" en la fila 2, columna 3:

Lcd_Chr (2, 3, 'i');
Lcd_Chr_Cp
Prototipo void Lcd_Chr_Cp ( char out_char);
Devoluciones Nada.
Descripción Imprime el carácter en Lcd en la posición actual del

cursor. Tanto las variables como los literales pueden
pasarse como un personaje.
Parámetros:

Ejemplo // Escriba el carácter "e" en la posición actual del

cursor:
Lcd_Chr_Cp ('e');
Lcd_Cmd
Prototipo void Lcd_Cmd ( char out_char);
Devoluciones Nada.
Descripción Envía el comando a Lcd.

Parámetros:
 out_char: comando para ser enviado
Nota: Se pueden pasar constantes predefinidas a la

función, consulte Comandos de Lcd disponibles .
Requiere El módulo Lcd necesita ser

inicializado. Ver tabla Lcd_Init .
Ejemplo // Borrar la pantalla LCD:
Lcd_Cmd (_LCD_CLEAR);
Comandos Lcd disponibles

Comando lcd Propósito
_LCD_FIRST_ROW Mueve el cursor a la 1ra fila
_LCD_SECOND_ROW Mueve el cursor a la segunda fila
_LCD_THIRD_ROW Mueve el cursor a la tercera fila
_LCD_FOURTH_ROW Mueve el cursor a la cuarta fila
_LCD_CLEAR Pantalla clara
_LCD_RETURN_HOME Regrese el cursor a la posición inicial, regresa una pantalla

desplazada a su posición original. La memoria RAM de datos
de visualización no se ve afectada.
_LCD_CURSOR_OFF Apagar el cursor
_LCD_UNDERLINE_ON Cursor de subrayado en
_LCD_BLINK_CURSOR_ON Parpadea el cursor en
_LCD_MOVE_CURSOR_LEFT Mueve el cursor hacia la izquierda sin cambiar la memoria

RAM de datos de visualización
_LCD_MOVE_CURSOR_RIGHT Mueva el cursor hacia la derecha sin cambiar la memoria RAM

de datos de visualización
_LCD_TURN_ON Encienda la pantalla LCD
_LCD_TURN_OFF Apagar pantalla lcd
_LCD_SHIFT_LEFT Desplazar pantalla a la izquierda sin cambiar los datos de

pantalla RAM
_LCD_SHIFT_RIGHT Desplazar la pantalla hacia la derecha sin cambiar los datos

de la pantalla RAM
El siguiente código demuestra el uso de las rutinas de la Biblioteca Lcd:


char txt1 [] = "mikroElektronika";

char txt2 [] = "EasyPIC6";
char txt3 [] = "Lcd4bit";
char txt4 [] = "ejemplo";
char i; // Variable de bucle
void Move_Delay () { // Función utilizada para mover

texto
Delay_ms (500); // Puedes cambiar la velocidad de
movimiento aquí
}
void main () {
digital
ANSELH = 0;
C2ON_bit = 0;

Lcd_Cmd (_LCD_CURSOR_OFF); // Cursor fuera de
Lcd_Out (1,6, txt3); // Escribe texto en primera fila
Lcd_Out (2,6, txt4); // Escribe texto en la segunda fila

Delay_ms (2000);
Lcd_Out (1,1, txt1); // Escribir texto en la primera

fila
Lcd_Out (2,5, txt2); // Escribe texto en la segunda fila
Delay_ms (2000);
// Mover texto
para (i = 0; i <4; i ++) { // Mover texto a la derecha 4
veces
Lcd_Cmd (_LCD_SHIFT_RIGHT);
Move_Delay ();
}
while (1) { // Bucle sin fin

para (i = 0; i <8; i ++) { // Mueve el texto a la
izquierda 7 veces
Lcd_Cmd (_LCD_SHIFT_LEFT);
Move_Delay ();
}
para (i = 0; i <8; i ++) { // Mueve el texto a la derecha

7 veces
Lcd_Cmd (_LCD_SHIFT_RIGHT);
Move_Delay ();
}
}
}
Conexión Lcd HW
Biblioteca de códigos de Manchester
El mikroC PRO para PIC proporciona una biblioteca para manejar señales
codificadas de Manchester. El código de Manchester es un código en el que los
datos y las señales de reloj se combinan para formar un único flujo de datos de
sincronización automática; cada bit codificado contiene una transición en el punto
medio de un período de bit, la dirección de transición determina si el bit es 0 o 1; la
segunda mitad es el valor de bit verdadero y la primera mitad es el complemento
del valor de bit verdadero (como se muestra en la siguiente figura).
Importante:
 Las rutinas de recepción de Manchester están bloqueando llamadas
( Man_Receive_Inity Man_Synchro). Esto significa que MCU esperará
hasta que se haya realizado la tarea (por ejemplo, se recibe el byte, se
logra la sincronización, etc.).
 La biblioteca de códigos de Manchester implementa actividades basadas
en el tiempo, por lo que las interrupciones deben desactivarse al
usarlas.
Dependencias externas de Manchester Code Library
Las siguientes
variables deben
definirse en todos los
Descripción
proyectos utilizando Ejemplo:
:
la Biblioteca de
códigos de
Manchester:
extern sfr
sbit MANRXPIN; Recibir línea. sbit MANRXPIN atRC0_bit;
extern sfr Línea de sbit MANTXPIN atRC1_bit;

sbit MANTXPIN; transmisión.

sbitMANRXPIN_Direction at TRISC0_b
sbitMANRXPIN_Directio pin de it;
n; recepción.
sbitMANTXPIN_Direction at TRISC1_b
sbitMANTXPIN_Directio pin de it;
n; transmisión.
 Man_Receive_Init
 Man_Reciba
 Man_Send_Init
 Man_Send
 Man_Synchro
 Man_Break
Las siguientes rutinas son solo para uso interno del compilador:
 Manchester_0
 Manchester_1
 Manchester_Out
Man_Receive_Init
Prototipo unsigned int Man_Receive_Init ();
Devoluciones  0 - Si la inicialización y la sincronización

tuvieron éxito.
 1 - En la sincronización sin éxito.
 255 - en caso de abortar usuario.
Descripción La función configura el pin del receptor y realiza el

procedimiento de sincronización para recuperar la
velocidad de transmisión de la señal entrante.
Nota: En caso de múltiples errores persistentes en la

recepción, el usuario debe llamar a esta rutina una vez
más o a la rutina Man_Synchropara habilitar la
sincronización.

 MANRXPIN : Línea de recepción
 MANRXPIN_Direction : Dirección del pin
receptor.
Ejemplo // Inicializar Receiver

sbit MANRXPIN en RC0_bit;
sbit MANRXPIN_Direction at TRISC0_bit;
...
Man_Receive_Init ();
Man_Reciba
Prototipo unsigned char Man_Receive ( unsigned char *
error);
Devoluciones Un byte leído de la señal entrante.
Descripción La función extrae un byte de la señal entrante.

Parámetros:
 error:bandera de error. Si el formato de la
señal no coincide con el esperado,
el errorindicador se establecerá en un valor
distinto de cero.
Requiere Para usar esta función, el usuario debe preparar el MCU

para recibir. Ver Man_Receive_Init .
Ejemplo datos de caracteres sin firmar = 0, error = 0;

...
datos = Man_Receive (& error);
si (error)
{ / * manejo de errores * / }
Man_Send_Init
Prototipo void Man_Send_Init ();
Devoluciones Nada.
Descripción La función configura el pin del transmisor.

 MANTXPIN : Línea de transmisión
 MANTXPIN_Direction : Dirección del pin de
transmisión.
Ejemplo // Inicializar transmisor:

sbit MANTXPIN en RC1_bit;
sbit MANTXPIN_Direction at TRISC1_bit;
...
Man_Send_Init ();
Man_Send
Prototipo void Man_Send ( unsigned char tr_data);
Devoluciones Nada.
Descripción Envía un byte.

Parámetros:
 tr_data: datos a enviar
Nota: la velocidad de transmisión utilizada es de 500

bps.
Requiere Para usar esta función, el usuario debe preparar el MCU

para enviar. Ver Man_Send_Init .
Ejemplo unsigned char msg;

...
Man_Send (msg);
Man_Synchro
Prototipo unsigned char Man_Synchro ();
Devoluciones  255 - Si la sincronización no tuvo éxito.

 La mitad de la longitud del bit de manchester,
dada en múltiplos de 10 us, tras una
sincronización exitosa.
Descripción Mide la mitad de la longitud de la broca del manchester con

una resolución de 10us.
Requiere Para usar esta función, primero debe preparar el MCU para
recibir. Ver Man_Receive_Init .
Ejemplo unsigned int man__half_bit_len;

...
man__half_bit_len = Man_Synchro ();
Man_Break
Prototipo void Man_Break ();
Devoluciones Nada.
Descripción Man_Receive está bloqueando la rutina y puede bloquear el

flujo del programa. Llame a esta rutina desde la
interrupción para desbloquear la ejecución del
programa. Este mecanismo es similar a WDT .
Nota: las interrupciones deben desactivarse antes de

volver a utilizar las rutinas de Manchester (vea la nota en
la parte superior de esta página).
Requiere Nada.
Ejemplo char data1, error, contador = 0;
interrupción del vacío {
if (INTCON.T0IF) {
if (contador> = 20) {
Man_Break ();
contador = 0; // reiniciar
contador
}
else
counter ++; // contador de
incrementos
INTCON.T0IF = 0; // Borrar indicador

de interrupción de desbordamiento del temporizador0
}
}
void main () {
OPTION_REG = 0x04; // preescalador TMR0

ajustado a 1:32
...
Man_Receive_Init ();
...
// prueba Man_Receive con el mecanismo de

prevención de bloqueo
INTCON.GIE = 1; // Habilitación de
interrupción global
INTCON.T0IE = 1; // Habilitar la
interrupción de desbordamiento del temporizador 0
data1 = Man_Receive (& error);
INTCON.GIE = 0; // Desactivación de
la interrupción global
...
}
El siguiente código es el código para el receptor de Manchester, muestra cómo usar
la Biblioteca de Manchester para recibir datos:


// Conexiones del módulo Manchester

// Terminar las conexiones del módulo Manchester
error char , ErrorCount, temp;
void main () {
ErrorCount = 0;
ANSEL = 0; // Configurar pines AN
como E / S digital
ANSELH = 0;
comparadores
C2ON_bit = 0;
TRISC.F5 = 0;
Lcd_Cmd (_LCD_CLEAR); // Pantalla LCD clara
Man_Receive_Init (); // Inicializar Receptor
Lcd_Cmd (_LCD_FIRST_ROW); // Mueve el cursor a la

1ra fila
while (1) { // Espere el byte de

inicio "
temp" = Man_Receive (& error); // byte Intento
recibir
si (temp == 0x0B) // "Inicio" byte, ver
Transmisor ejemplo
romper ; // Obtuvimos la
secuencia de inicio
si (error) // Salir para no
interrumpir el ciclo para siempre ;
}
hacer
{
temp = Man_Receive (& error); // Intentar byte
recibir
si (error) { // Si ocurrió un error
Lcd_Chr_CP ('?'); // Escriba el signo de
interrogación en LCD
ErrorCount ++; // Actualizar el
contador de errores
si (ErrorCount> 20) { // En caso de errores
múltiples
temp = Man_Synchro (); // Intente sincronizar
nuevamente
// Man_Receive_Init (); // Alternativa, intente inicializar
Receiver nuevamente
ErrorCount = 0; // Restablecer contador
de errores
}
}
else { // No se produjo ningún
error
si (temp! = 0x0E) // Si se recibió el
byte "Fin" (vea el ejemplo del transmisor)
Lcd_Chr_CP (temp); // no escribir byte
recibido en LCD
}
Delay_ms (25);
}
mientras (temp! = 0x0E); // Si se recibió el
byte "Fin" salga del bucle
}
}
El siguiente código es el código para el transmisor de Manchester, muestra cómo

usar la Biblioteca de Manchester para transmitir datos:
// Conexiones del módulo Manchester

// Terminar las conexiones del módulo Manchester
Char índice, carácter;

char s1 [] = "mikroElektronika";
void main () {

digital
ANSELH = 0;
C2ON_bit = 0;
Man_Send_Init (); // Inicializar transmisor
while (1) { // Endless loop

Man_Send (0x0B); // Enviar "inicio" byte
Delay_ms (100); // espera un rato
carácter = s1 [0]; // Toma el primer carácter del

índice de cadena = 0; // Inicializar la variable
de índice
while (carácter) { // La cadena termina con cero
Man_Send (carácter); // Enviar carácter
Delay_ms (90); // Espera un momento
index ++; //
Carácter variable del índice de incremento = s1 [índice]; //
Toma el siguiente char de la cadena
}
Man_Send (0x0E); // Enviar byte final
Delay_ms (1000);
}
}
Ejemplo de conexión
Conexión simple del transmisor

Conexión de receptor simple
Biblioteca del administrador de memoria
Esta biblioteca proporciona rutinas para manipular la asignación de memoria
dinámica. La asignación de memoria dinámica (también conocida como asignación
de memoria basada en heap) es la asignación de almacenamiento de memoria para
su uso en un programa durante el tiempo de ejecución de ese programa.
La memoria asignada dinámicamente existe hasta que se libera. Esto contrasta con
la asignación de memoria estática, que tiene una duración fija. Se dice que un
objeto así asignado tiene un tiempo de vida dinámico.
El tamaño de la memoria del montón se puede configurar en la ventana Editar
proyecto . Además, el usuario puede anular el tamaño de la memoria del montón
en el código, configurando la HEAP_SIZEconstante.
 MM_Init
 Malloc
 FreeMem
 MM_LargestFreeMemBlock
 MM_TotalFreeMemSize
MM_Init
Prototipo void MM_Init ();
Descripción Establece el tamaño del montón.
Parámetros Ninguna.
Devoluciones Nada.
Requiere Nada.
Ejemplo MM_Init (); // establecer el tamaño del

montón
Notas Ninguna.
Malloc
Prototipo void * Malloc ( tamaño largo sin firmar );
Descripción Asigna un bloque de bytes de tamaño de memoria,

devolviendo un puntero al principio del bloque. El contenido
del bloque de memoria recién asignado no se inicializa y
permanece con valores indeterminados.
Parámetros  Size: Tamaño del bloque de memoria, en

bytes.
Devoluciones Devuelve un puntero al bloque de memoria asignado por la

función.
Si la función no pudo asignar el bloque de memoria
solicitado, se devuelve un puntero nulo.
Requiere Nada.
Ejemplo int * pi; // puntero a entero

int ai [100]; // matriz de enteros
void main () {
pi = ( int *) malloc ( sizeof ai); // pi apuntará
a un bloque de memoria donde se asigna la matriz
}
Notas El tipo de este puntero siempre es nulo, que se puede

convertir al tipo deseado de puntero de datos para que no
se pueda hacer referencia.
FreeMem
Prototipo void FreeMem ( char * P, tamaño largo sin
firmar );
Descripción Esta función se utiliza para liberar el bloque de memoria

asignado por Malloc .
Parámetros  P: puntero al bloque de memoria

 Size: Tamaño real del bloque de memoria.
Devoluciones Nada.
Requiere Nada.
Ejemplo int * pi; // puntero a entero

int ai [100]; // matriz de enteros
void main () {
pi = ( int *) malloc ( sizeof ai); // pi apuntará
a un bloque de memoria en el Heap donde se asigna la
matriz
Free (pi, sizeof (pi)); // libera el
bloque de memoria del montón asignado por Malloc,
apuntado por el puntero pi
}
Notas Ninguna.
MM_LargestFreeMemBlock
Prototipo sin firmar largo MM_LargestFreeMemBlock ();
Descripción Esta función se utiliza para determinar el bloque de

memoria libre más grande disponible para el montón.
Devoluciones El bloque de memoria libre más grande para el montón.
Requiere Nada.
Ejemplo bloque largo sin firmar ;
void main () {
bloque = MM_LargestFreeMemBlock ();
}
Notas Ninguna.
MM_TotalFreeMemSize
Prototipo largo sin firmar MM_TotalFreeMemSize ();
Descripción Esta función se utiliza para determinar el tamaño total de

la memoria libre.
Devoluciones Tamaño total de memoria libre.
Requiere Nada.
Ejemplo total largo sin firmar ;
void main () {
bloque = MM_TotalFreeMemSize ();
}
Notas Ninguna.
Biblioteca de tarjetas multimedia
La tarjeta multimedia (MMC) es una tarjeta de memoria flash estándar. Las tarjetas
MMC están actualmente disponibles en tamaños de hasta 32 GB, e incluyen en
teléfonos celulares, reproductores de audio digital, cámaras digitales y PDA .
mikroC PRO for PIC proporciona una biblioteca para acceder a los datos de la
tarjeta multimedia a través de la comunicación SPI . Esta biblioteca también admite
tarjetas de memoria SD (Secure Digital) y SDHC (Secure Digital High Capacity) de
alta capacidad.
Tarjeta Secure Digital
Secure Digital (SD) es un estándar de tarjeta de memoria Flash, basado en el
formato anterior de Tarjeta Multi Media (MMC).
Las tarjetas SD actualmente están disponibles en tamaños de hasta 2 GB, e
incluyen cámaras digitales, videocámaras digitales, computadoras de mano,
reproductores de medios, teléfonos móviles, receptores GPS, videojuegos y PDA .
Tarjeta Secure Digital de alta capacidad
SDHC (Secure Digital High Capacity, SD 2.0) es una extensión del estándar SD que
aumenta la capacidad de almacenamiento de la tarjeta hasta 32 GB al usar el
direccionamiento de sector en lugar del direccionamiento de bytes en el estándar
SD anterior.
Las tarjetas SDHC comparten el mismo factor de forma física y eléctrica que las
tarjetas más antiguas (SD 1.x), lo que permite que los dispositivos SDHC admitan
las tarjetas SDHC más nuevas y las tarjetas SD más antiguas. El estándar actual
limita la capacidad máxima de una tarjeta SDHC a 32 GB.
Importante:
 Las rutinas para el manejo de archivos solo pueden usarse con el
 Las funciones de la biblioteca crean y leen archivos solo desde el
directorio raíz.
 Las funciones de biblioteca llenan las tablas FAT1 y FAT2 al escribir en
archivos, pero los datos del archivo se leen solo desde la tabla FAT1; es
decir, no hay recuperación si la tabla FAT1 se corrompe.
 Si la tarjeta MMC / SD tiene un registro de inicio maestro (MBR), la
biblioteca funcionará con la primera partición primaria (lógica)
disponible que tiene un tamaño distinto de cero. Si la tarjeta MMC / SD
tiene Volume Record Record (es decir, solo hay una partición lógica y
no MBR), la biblioteca funciona con la tarjeta completa como una sola
partición. Para obtener más información sobre MBR, unidades físicas y
lógicas, particiones primarias / secundarias y tablas de particiones,
consulte otros recursos, por ejemplo, Wikipedia y similares.
 Antes de la operación de escritura, asegúrese de no sobrescribir el
sector de arranque o FAT, ya que podría hacer que su tarjeta en una PC
o cámara digital sea ilegible. Las herramientas de mapeo de unidades,
como Winhex, pueden ser de gran ayuda.
inicializar el módulo SPI apropiado antes de usar la biblioteca MMC .
 Para MCU con múltiples módulos SPI es posible inicializarlos todos y
luego cambiarlos usando la SPI_Set_Active()función. Ver las funciones
de la biblioteca SPI .
 La biblioteca MMC FAT 16 solo funciona con la familia PIC18.
El módulo SPI debe inicializarse mediante la SPIx_Init_Advancedrutina con los
siguientes parámetros:
 SPI Master
 Prescaler primario 64
 Datos muestreados en medio del tiempo de salida de datos
 Reloj inactivo bajo
 Los datos de salida en serie cambian en forma de transición de borde
bajo a borde alto
Consejo: Una vez que se inicializa la tarjeta MMC / SD, el módulo SPI se
puede reinicializar a una velocidad mayor. Ver
las rutinas Mmc_Init y Mmc_Fat_Init .
Dependencias externas de la biblioteca MMC

La siguiente variable
debe definirse en todos Descripci
Ejemplo:
los proyectos usando la ón:
biblioteca MMC:
Chip de
extern sfr
sbitMmc_Chip_Select; selección sbit Mmc_Chip_Select atRC0_bit;
de pin.
Dirección
extern sfr
sbitMmc_Chip_Select_Dir del pin de sbitMmc_Chip_Select_Direction at T
ection; selección RISC0_bit;
de chip.
 Mmc_Init
 Mmc_Read_Sector
 Mmc_Write_Sector
 Mmc_Read_Cid
 Mmc_Read_Csd
 Mmc_Multi_Read_Start
 Mmc_Multi_Read_Sector
 Mmc_Multi_Read_Stop
Rutinas para el manejo de archivos:
 Mmc_Fat_Init
 Mmc_Fat_QuickFormat
 Mmc_Fat_Assign
 Mmc_Fat_Reset
 Mmc_Fat_Read
 Mmc_Fat_Rewrite
 Mmc_Fat_Append
 Mmc_Fat_Delete
 Mmc_Fat_Write
 Mmc_Fat_Set_File_Date
 Mmc_Fat_Get_File_Date
 Mmc_Fat_Get_File_Date_Modified
 Mmc_Fat_Get_File_Size
 Mmc_Get_File_Write_Sector
 Mmc_Fat_Get_Swap_File
 Mmc_Fat_Tell
 Mmc_Fat_Seek
 Mmc_Fat_Rename
 Mmc_Fat_MakeDir
 Mmc_Fat_RenameDir
 Mmc_Fat_RemoveDir
 Mmc_Fat_ChangeDir
 Mmc_Fat_Exists
 Mmc_Fat_Dir
 Mmc_Fat_ReadDir
 Mmc_Fat_Activate
 Mmc_Fat_ReadN
 Mmc_Fat_Open
 Mmc_Fat_Close
 Mmc_Fat_EOF
Mmc_Init
Prototipo unsigned char Mmc_Init ();
Devoluciones  0 - Si la tarjeta MMC / SD se detectó y se

inicializó correctamente
Descripción Inicializa MMC a través de la interfaz de hardware SPI .

Se debe llamar a Mmc_Init antes de usar otras funciones
de esta biblioteca.
Requiere El módulo SPI de hardware apropiado debe inicializarse

previamente.
Variables globales :
 Mmc_Chip_Select: Línea Chip Select
 Mmc_Chip_Select_Direction: Dirección del pin
Chip Select
El módulo SPI de hardware apropiado debe inicializarse
previamente. Consulte
las rutinas SPI1_Init , SPI1_Init_Advanced .
Ejemplo // Conexiones del módulo MMC

sfr sbit Mmc_Chip_Select at RC0_bit;
sfr sbit Mmc_Chip_Select_Direction en TRISC0_bit;
// Conexiones del módulo MMC
...
SPI1_Init ();
error = Mmc_Init (); // Inicial con línea CS en

RC0_bit
Mmc_Read_Sector
Prototipo unsigned char Mmc_Read_Sector ( unsigned
long sector, char * dbuff);
Devoluciones  0 - si la lectura fue exitosa

 1 - si ocurrió un error
Descripción La función lee un sector (512 bytes) de la tarjeta MMC.

Parámetros:
 sector: Sector de tarjetas MMC / SD para leer.
 dbuff: Búfer de 512 bytes de longitud mínima
para almacenamiento de datos.
Requiere La tarjeta MMC / SD debe estar inicializada. Ver Mmc_Init .
Ejemplo // leer el sector 510 de la tarjeta MMC / SD

unsigned int error;
sector largo sin firmarNo = 510;
char dataBuffer [512];
...
error = Mmc_Read_Sector (sectorNo, dataBuffer);
Mmc_Write_Sector
Prototipo unsigned char Mmc_Write_Sector ( unsigned
long sector, char * dbuff);
Devoluciones  0 - si la escritura fue exitosa

 1 - si hubo un error al enviar el comando de
escritura
 2 - si hubo un error por escrito (datos
rechazados)
Descripción La función escribe 512 bytes de datos en un sector de

tarjeta MMC.
Parámetros:
 sector: Sector de tarjeta MMC / SD para ser
escrito.
 dbuff: Datos a escribir (buffer de mínimo 512
bytes de longitud).
Ejemplo // escriba al sector 510 de la tarjeta MMC / SD

unsigned int error;
sector largo sin firmarNo = 510;
...
error = Mmc_Write_Sector (sectorNo, dataBuffer);
Mmc_Read_Cid
Prototipo unsigned char Mmc_Read_Cid ( char * data_cid);
Devoluciones  0 - Si el registro CID fue leído con éxito.

 1 - si hubo un error al leer
Descripción La función lee el registro CID de 16 bytes.

Parámetros:
 data_cid: Búfer de 16 bytes de longitud
mínima para almacenar el contenido del
registro CID.

Ejemplo error int sin firmar ;
...
error = Mmc_Read_Cid (dataBuffer);
Mmc_Read_Csd
Prototipo unsigned char Mmc_Read_Csd ( char * data_csd);
Devoluciones  0 - Si el registro CSD fue leído con éxito.

 1 - si hubo un error al leer
Descripción La función lee el registro CSD de 16 bytes.

Parámetros:
 data_csd: Búfer de 16 bytes de longitud
mínima para almacenar el contenido del
registro CSD.

...
error = Mmc_Read_Csd (dataBuffer);
Mmc_Multi_Read_Start
Prototipo unsigned int Mmc_Multi_Read_Start ( sector largo
sin firmar );
Descripción La función inicia el modo de lectura múltiple, los sectores

se leen secuencialmente a partir del sector dado en el
argumento de la función.
Parámetros  sector: Número de sector inicial.
Devoluciones  0 - Si el inicio de lectura múltiple fue exitoso.

 1 - Se produjo un error.

sector char
...
error = Mmc_Multi_Read_Start (sector);
Notas Ninguna.
Mmc_Multi_Read_Sector
Prototipo void Mmc_Multi_Read_Sector (char * dbuff);
Descripción La función lee sectores en modo de lectura múltiple y los

coloca en el búfer dado como el argumento de la
función. La siguiente llamada de función lee el sector
subsiguiente. El tamaño del búfer debe ser 512B.
Parámetros  dbuff: buffer para la celebración de los datos
del sector.
Devoluciones Nada.

...
Mmc_Multi_Read_Sector (buffer);
Notas Ninguna.
Mmc_Multi_Read_Stop
Prototipo unsigned int Mmc_Multi_Read_Stop ();
Descripción La función detiene la secuencia de modo de lectura

múltiple.
Devoluciones  0 - Si la parada fue exitosa.

 1 - Se detectó un error.
Ejemplo Mmc_Multi_Read_Stop;
Notas Ninguna.
Mmc_Fat_Init
Prototipo corto sin firmar Mmc_Fat_Init ();
Devoluciones  0 - Si la tarjeta MMC / SD se detectó y se

inicializó correctamente
 1 - si no se encontró el sector de arranque
FAT16
 255 - Si la tarjeta MMC / SD no fue detectada
Descripción Inicializa la tarjeta MMC / SD, lee el sector de arranque

MMC / SD FAT16 y extrae los datos necesarios que
necesita la biblioteca.
Nota: la tarjeta MMC / SD debe formatearse para el


 Mmc_Chip_Select: Línea Chip Select
 Mmc_Chip_Select_Direction: Dirección del pin
Chip Select
El módulo SPI de hardware apropiado debe inicializarse
previamente. Consulte
las rutinas SPI1_Init , SPI1_Init_Advanced .
Ejemplo // Conexiones del módulo MMC

sfr sbit Mmc_Chip_Select at RC0_bit;
sfr sbit Mmc_Chip_Select_Direction en TRISC0_bit;
// Inicializar el módulo SPI1

SPI1_Init_Advanced (_SPI_MASTER_OSC_DIV64,
_SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW,
_SPI_LOW_2_HIGH);
// use el formato rápido fat16 en lugar de la rutina

init si se necesita un formato
if (! Mmc_Fat_Init ()) {
// reiniciar SPI1 a mayor velocidad
SPI1_Init_Advanced (_SPI_MASTER_OSC_DIV4,
_SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW,
_SPI_LOW_2_HIGH);
...
}
Mmc_Fat_QuickFormat
Prototipo unsigned char Mmc_Fat_QuickFormat ( char *
mmc_fat_label);
Devoluciones  0 - si se detectó una tarjeta MMC / SD, se

formateó correctamente y se inicializó
 1 - si el formato FAT16 no tuvo éxito
 255 - Si la tarjeta MMC / SD no fue detectada
Descripción Se aplica a FAT16 e inicializa la tarjeta MMC / SD.

Parámetros:
 mmc_fat_label:Etiqueta de volumen (11
caracteres de longitud). Si se proporcionan
menos de 11 caracteres, la etiqueta se
rellenará con espacios. Si se pasa una cadena
nula, el volumen no será etiquetado.
Nota :
 Esta rutina se puede utilizar en su lugar o junto
con la rutina Mmc_Fat_Init .
 Si la tarjeta MMC / SD ya contiene un sector de
inicio válido, permanecerá sin cambios
(excepto el campo de etiqueta de volumen) y
solo se borrarán las tablas FAT y
ROOT. Además, se establecerá la nueva
etiqueta de volumen.
Requiere El módulo SPI de hardware apropiado debe inicializarse

previamente.
Ejemplo // Formatee e inicialice los indicadores globales de

la tarjeta MMC / SD y MMC_FAT16
si (! Mmc_Fat_QuickFormat (& mmc_fat_label)) {
...
}
Mmc_Fat_Assign
Prototipo corto sin firmar Mmc_Fat_Assign ( char *
filename, charfile_cre_attr);
Devoluciones  2 - Si no hay más manejadores de archivos

libres, el archivo actualmente abierto se cierra
para liberar espacio.
 1 - si el archivo ya existe o el archivo no existe
pero se crea un nuevo archivo.
 0 - si el archivo no existe y no se crea ningún
archivo nuevo.
Descripción Asigna archivos para operaciones de archivos (leer,

escribir, eliminar ...). Todas las operaciones de archivo
subsiguientes se aplicarán en un archivo asignado.
Parámetros:
8.3 (file_name.extension). El nombre y la
extensión del archivo serán rellenados
 file_cre_attr:Creación de archivos y
distintivos de atributos. Cada bit corresponde al
atributo apropiado del archivo:
0 0x01 Solo lectura
1 0x02 Oculto
2 0x04 Sistema
5 0x20 Archivo

6 0x40
especificado.

Requiere La tarjeta MMC / SD y la biblioteca MMC deben inicializarse

para las operaciones de archivos. Ver Mmc_Fat_Init .
Ejemplo // crear archivo con atributo de archivo si no

existe ya
Mmc_Fat_Assign ("MIKRO007.TXT", 0xA0);
Mmc_Fat_Reset
Prototipo void Mmc_Fat_Reset ( unsigned long * size);
Devoluciones Nada.
Descripción El procedimiento restablece el puntero del archivo (lo

mueve al inicio del archivo) del archivo asignado, para que
el archivo pueda leerse.
Parámetros:
 size:búfer para almacenar el tamaño del
archivo a. Después de que el archivo se haya
abierto para su lectura, su tamaño se devuelve

previamente. Ver Mmc_Fat_Assign .
Ejemplo tamaño largo sin firmar ;

...
Mmc_Fat_Reset (& size);
Mmc_Fat_Read
Prototipo void Mmc_Fat_Read ( short * bdata sin signo);
Devoluciones Nada.
Descripción Lee un byte del archivo asignado actualmente abierto para

leer. Tras la ejecución de la función, los punteros de
archivo se establecerán en el siguiente carácter del
archivo.
Parámetros:
 bdata:búfer para almacenar el byte de lectura
a. A través de este parámetro, se devuelve el
byte de lectura de esta función.
El archivo debe estar abierto para su
lectura. Ver Mmc_Fat_Reset .
Ejemplo personaje char

...
Mmc_Fat_Read (& carácter);
Mmc_Fat_Rewrite
Prototipo void Mmc_Fat_Rewrite ();
Devoluciones Nada.
Descripción Abre el archivo asignado actualmente para la escritura. Si

el archivo no está vacío, su contenido será borrado.

Ejemplo // abrir archivo para escribir

Mmc_Fat_Rewrite ();
Mmc_Fat_Append
Prototipo void Mmc_Fat_Append ();
Devoluciones Nada.
Descripción Abre el archivo asignado actualmente para anexar. Sobre

esta función, los punteros del archivo de ejecución se
colocarán después del último byte en el archivo, por lo que
cualquier operación de escritura de archivo posterior
comenzará desde allí.

Ejemplo // abrir archivo para

agregar Mmc_Fat_Append ();
Mmc_Fat_Delete
Prototipo char Mmc_Fat_Delete ();
Devoluciones  1 - si no hay archivos asignados

 2 - si ocurrió un error durante la eliminación
 0 - si la eliminación fue exitosa
Descripción Borra el archivo asignado actualmente de la tarjeta MMC /
SD.

Ejemplo // eliminar el archivo actual

si (Mmc_Fat_Delete () == 0)
...
Mmc_Fat_Write
Prototipo void Mmc_Fat_Write ( char *
fdata, unsigned data_len);
Devoluciones Nada.
Descripción Escribe el número solicitado de bytes en el archivo

asignado actualmente abierto para escritura.
Parámetros:
 fdata: Datos a escribir.
 data_len: Número de bytes a escribir.

escritura. Consulte Mmc_Fat_Rewrite o Mmc_Fat_Append .
Ejemplo Mmc_Fat_Write (txt, 255);

Mmc_Fat_Write ("Hello world", 255);
Mmc_Fat_Set_File_Date
Prototipo void Mmc_Fat_Set_File_Date ( unsigned
int year, unsigned shortmonth, unsigned
short day, unsigned short hours, unsigned
shortminute, unsigned short seconds);
Devoluciones Nada.
Descripción Establece el sello de fecha / hora. Cualquier operación

subsiguiente de escritura de archivo escribirá este sello en
los atributos de hora / fecha del archivo asignado
actualmente.
Parámetros:
 year:año atributo Valores válidos: 1980-2107.
 month:atributo del mes. Valores válidos: 1-12
 day:atributo del día. Valores válidos: 1-31
 hours:Atributo de horas. Valores válidos: 0-23
 mins:atributo de minutos. Valores válidos: 0-
59.
 seconds:atributo de segundos Valores válidos:
0-59.

escritura. Consulte Mmc_Fat_Rewrite o Mmc_Fat_Append .
Ejemplo // 1 de abril de 2005, 18:07:00

Mmc_Fat_Set_File_Date (2005, 4, 1, 18, 7, 0);
Mmc_Fat_Get_File_Date
Prototipo void Mmc_Fat_Get_File_Date ( unsigned int *
year, unsigned short * month, unsigned short *
day, unsigned short * hours, unsigned short *
mins);
Devoluciones Nada.
Descripción Lee los atributos de hora / fecha del archivo asignado

actualmente.
Parámetros:
 year:buffer para almacenar el atributo del año
a. Al ejecutarse la función, el atributo año se
 month:buffer para almacenar el atributo del
mes a. A la ejecución de la función, el atributo
del mes se devuelve a través de este
parámetro.
 day:buffer para almacenar el atributo del día
a. A la ejecución de la función, el atributo día
 hours:búfer para almacenar las horas
atribuidas a. A la ejecución de la función, el
atributo horas se devuelve a través de este
parámetro.
 mins:buffer para almacenar el atributo de
minutos a. A la ejecución de la función, el
atributo de minutos se devuelve a través de
este parámetro.

Ejemplo // obtener Fecha / hora del archivo

sin firmar yr;
char mnth, dat, hrs, mins;
...
file_Name = "MYFILEABTXT";
Mmc_Fat_Assign (nombre_archivo);
Mmc_Fat_Get_File_Date (& yr, & mnth, & day, & hrs, &
mins);
Mmc_Fat_Get_File_Date_Modified
Prototipo void Mmc_Fat_Get_File_Date_Modified ( unsigned
int * year, unsigned short * month, unsigned
short * day, unsigned short * hours, unsigned
short * mins);
Devoluciones Nada.
Descripción Recupera la fecha / hora de la última modificación para el

archivo seleccionado actualmente.
Parámetros:
 year:buffer para almacenar el año de
la función, el atributo de modificación se
 month:buffer para almacenar el mes del
atributo de modificación a. Tras la ejecución de
la función, el mes de modificación del atributo
 day:buffer para almacenar el día del atributo
de modificación a. Tras la ejecución de la
función, el atributo de modificación se devuelve
 hours:buffer para almacenar horas de
la función, se devuelve el atributo de
modificación a través de este parámetro.
 mins:buffer para almacenar minutos de
la función, el atributo de modificación de
minutos se devuelve a través de este
parámetro.

Ejemplo // obtener modificación Fecha / hora del archivo

sin firmar yr;
...
file_Name = "MYFILEABTXT";
Mmc_Fat_Get_File_Date_Modified (& yr, & mnth, & day,
& hrs, & mins);
Mmc_Fat_Get_File_Size
Prototipo sin signo largo Mmc_Fat_Get_File_Size ();
Devoluciones Esta función devuelve el tamaño del archivo activo (en
bytes).
Descripción Esta función lee el tamaño del archivo asignado

actualmente en bytes.

Ejemplo // obtener Fecha / hora del archivo

sin firmar yr;
...
nombre_archivo = "MYFILEXXTXT";
mmc_size = Mmc_Fat_Get_File_Size;
Mmc_Get_File_Write_Sector
Prototipo sin firmar largo Mmc_Get_File_Write_Sector ();
Descripción Esta función devuelve el sector de escritura del archivo

actual.
Devoluciones Esta función devuelve el sector de escritura del archivo

actual.

Ejemplo sector largo sin firmar ;

...
sector = Mmc_Get_File_Write_Sector ();
Notas Ninguna.
Mmc_Fat_Get_Swap_File
Prototipo sin firmar largo Mmc_Fat_Get_Swap_File ( sin signo
largos sectores_cnt, char * nombre de
archivo, char archivo_attr);
Devoluciones  Número del sector de inicio para el archivo de

intercambio recién creado, si había suficiente
espacio libre en la tarjeta MMC / SD para crear
el archivo del tamaño requerido.
Descripción Esta función se utiliza para crear un archivo de intercambio
de nombre y tamaño predefinidos en el medio MMC /
SD. Si ya existe un archivo con el nombre especificado en
el medio, la búsqueda de sectores consecutivos ignorará
los sectores ocupados por este archivo. Por lo tanto, se
recomienda borrar dicho archivo si ya existe antes de
llamar a esta función. Si no se borra y todavía hay espacio
suficiente para un nuevo archivo de intercambio, esta
función lo eliminará después de asignar un nuevo espacio
de memoria para un nuevo archivo de intercambio.
El propósito del archivo de intercambio es hacer que la
lectura y escritura en el medio MMC / SD sea lo más rápida
posible, utilizando las funciones Mmc_Read_Sector
() y Mmc_Write_Sector () directamente, sin dañar el
sistema FAT. El archivo de intercambio se puede considerar
como una "ventana" en el medio donde el usuario puede
escribir / leer datos libremente. Su propósito principal en la
biblioteca es ser usado para la adquisición rápida de
datos; cuando la adquisición crítica de tiempo ha finalizado,
los datos pueden reescribirse en un archivo "normal" y
formatearse de la manera más adecuada.
Parámetros:
 sectors_cnt: número de sectores consecutivos
que el usuario desea que tenga el archivo de
intercambio.
8.3 (file_name.extension). El nombre y la
extensión del archivo serán rellenados
Además, para mantener la compatibilidad hacia
atrás con la primera versión de esta biblioteca,
los nombres de archivo se pueden ingresar
como cadena de MAYÚSCULAS de 11 bytes de
nombre de archivo y la extensión (es decir,
"MIKROELETXT" -> MIKROELE.TXT). En este
 file_attr:Creación de archivos y distintivos de
atributos. Cada bit corresponde al atributo
apropiado del archivo:
0 0x01 Solo lectura

1 0x02 Oculto
2 0x04 Sistema
5 0x20 Archivo

6 0x40
7 0x80 No utilizado


para las operaciones de archivos. Ver Mmc_Fat_Init.
Ejemplo // -------------- Intenta crear un archivo de

intercambio, cuyo tamaño será de al menos 100
sectores.
// Si tiene éxito, envía el No. de sector de inicio
a través de UART
tamaño = Mmc_Fat_Get_Swap_File (100);
si (tamaño <> 0) {
UART1_Write (0xAA);
UART1_Write (Lo (tamaño));
UART1_Write (Hola (tamaño));
UART1_Write (Mayor (tamaño));
UART1_Write (el más alto (tamaño));
UART1_Write (0xAA);
}
}
Mmc_Fat_Tell
Prototipo sin firmar largo Mmc_Fat_Tell ();
Descripción Esta rutina se utiliza para recuperar la posición del cursor

dentro de un archivo abierto.
Devoluciones Devuelve la posición del cursor en el archivo asignado

actualmente.

Ejemplo posición larga sin firmar ;
posición = Mmc_Fat_Tell ();
Notas Ninguna.
Mmc_Fat_Seek
Prototipo largo sin firmar Mmc_Fat_Seek ( posición larga sin
signo );
Descripción Esta rutina se utiliza para establecer la posición del cursor

dentro de un archivo abierto y devuelve la nueva posición
del cursor dentro de un archivo abierto.
Parámetros  position: Posición deseada en la que

queremos situar el cursor.
Devoluciones Devuelve la nueva posición del cursor en el archivo

asignado actualmente.

Ejemplo posición larga sin firmar ;
posición = Mmc_Fat_Seek (1000);
Notas Si la posición del cursor deseada excede el tamaño del

archivo, el cursor se colocará al final del archivo.
Mmc_Fat_Rename
Prototipo char Mmc_Fat_Rename ( char * newname);
Descripción Esta función cambia el nombre del archivo asignado

actualmente.
Parámetros  newname: Nuevo nombre de archivo.
Devoluciones  1 - si no hay archivos asignados

 2 - si el nuevo nombre es invalidado
 3 - si el archivo con el nuevo nombre ya existe
 4 - si ocurrió un error durante el cambio de
nombre
 0 - si el cambio de nombre fue exitoso

Ejemplo if (0 == Mmc_Fat_Rename ("NEWNAME.TXT")) { //

si la operación de cambio de nombre fue exitosa ...
...
}
Notas Ninguna.
Mmc_Fat_MakeDir
Prototipo char Mmc_Fat_MakeDir ( char * name, char attrib);
Descripción Esta función crea un nuevo directorio.
Parámetros  name: nombre del directorio.

 attrib: atributo del directorio.
Devoluciones  0 - la creación del directorio fue exitosa

 255 - si ocurrió un error

Ejemplo if (0 == Mmc_Fat_MakeDir ("DIR_A")) { // create

DIR_A directory
...
}
Notas Ninguna.
Mmc_Fat_RenameDir
Prototipo char Mmc_Fat_RenameDir ( char * oldname, char *
newname);
Descripción Esta función cambia el nombre de un directorio.
Parámetros  oldname: antiguo nombre de directorio.

 newname: Nuevo nombre de directorio.
Devoluciones  1 - si el nombre del directorio no es válido

 2 - Si no hay directry con el antiguo nombre.
 3 - Si ya existe una entrada con el nuevo
nombre.
 4 - si ocurrió un error durante el cambio de
nombre
 0 - si el cambio de nombre fue exitoso

Ejemplo if (0 == Mmc_Fat_RenameDir ("DIR_A", "DIR_B")) { //
si la operación de cambio de nombre fue exitosa ...
...
}
Notas Ninguna.
Mmc_Fat_RemoveDir
Prototipo char Mmc_Fat_RemoveDir ( char * name);
Descripción Esta función elimina la entrada de directorio del directorio

actual.
Devoluciones  1 - si el nombre del directorio no es válido

 2 - si el nombre del directorio no existe
 3 - si el directorio no está vacío
 4 - si se produjo un error al escribir
 0 - si la operación fue exitosa

Ejemplo if (0 == Mmc_Fat_RemoveDir ("DIR_A")) { // si la

operación de eliminación se realizó correctamente
...
...
}
Notas La eliminación recursiva no está soportada, es decir, el

directorio debe estar vacío antes de que se pueda eliminar.
Mmc_Fat_ChangeDir
Prototipo char Mmc_Fat_ChangeDir ( char * name);
Descripción Esta función cambia el directorio actual a name.
Devoluciones  0 - si la operación fue exitosa

 1 - si no hay entrada con el nombre de
directorio dado
 2 - si una entrada con el nombre dado no es un
directorio

Ejemplo // ingrese el directorio DIR_A

si (0 == Mmc_Fat_ChangeDir ("DIR_A")) {
...
}
// ir al directorio principal
si (0 == Mmc_Fat_ChangeDir ("..")) {
...
}
// ir al directorio raíz
si (0 == Mmc_Fat_ChangeDir ("\")) {
...
}
Notas También se admiten nombres de directorio especiales como

" ." y " ..".
Mmc_Fat_Exists
Prototipo char Mmc_Fat_Exists ( char * name);
Descripción Esta función devuelve información sobre la existencia del

archivo / directorio.
Parámetros  name: nombre de archivo / directorio.
Devoluciones  0 - si el archivo / directorio no existe

 1 - si el archivo / directorio existe

Ejemplo status = Mmc_Fat_Exists ("X_FILES.TXT");
if (1 == status) {...} // si se encontró

el archivo ...
si no (0 == estado) {...} // o si no se
encontró el archivo ...
else {...} // o si hubo un

error durante la llamada a la
función,
// que necesita ser
manejado por separado.
Notas Ninguna.
Mmc_Fat_Dir
Prototipo char Mmc_Fat_Dir ( void (* print) ( char ch))
Descripción Esta rutina muestra el contenido del directorio actual a

través de un medio definido por el usuario (es decir, un
módulo UART, un archivo en el sistema de archivos
FAT16). La función muestra carácter por carácter.
Parámetros  ch: Puntero de función a una rutina que

mostrará el contenido del directorio actual.
Devoluciones  1 - si el archivo nema no es válido

 2 - si el archivo ya existe
 3 - si se produjo un error al escribir
 0 - si la operación fue exitosa

Ejemplo // Mostrando la rutina

void PrintChar ( char ch) {
UART1_Write (ch);
}
...
Mmc_Fat_Dir (PrintChar);
Notas Ninguna.
Mmc_Fat_ReadDir
Prototipo estático corto Mmc_Fat_ReadDir (DIR * d);
Descripción Esta función obtiene la siguiente entrada de directorio del

directorio actual.
Parámetros  d: entrada de directorio (válida si el valor de

retorno es igual a 1), consistió en los siguientes
campos:
typedef struct
{
nombre de personaje sin firmar [13]; //
nombre del directorio
unsigned char attrib; //
atributo del directorio
unsigned char ctime [6]; //
crea hora y fecha
unsigned char mtime [6]; //
modificación de hora y fecha
sin firmar de largo tamaño; //
directorio de tamaño
sin firmar int primero; //
directorio start cluster
unsigned long sect; //
entrada de directorio sector
unsigned int entrada; //
Número de entrada en el sector de entrada.
} DIR;
Devoluciones  < 0 - si ocurrió un error

 0 - si no hay más entradas
 1 - si se devuelve una entrada válida

Ejemplo if (1 == Mmc_Fat_ReadDir ("DIR_A")) {

...
}
Notas Ninguna.
Mmc_Fat_Activate
Prototipo char Mmc_Fat_Activate ( short fileHandle);
Descripción Esta función selecciona el archivo activo de los archivos

abiertos actualmente.
Parámetros  fileHandle: Manejador de archivo del archivo

que necesita ser activado.
Devoluciones  0 - si la activación fue exitosa

 1 - si el manejador de archivo está fuera de
alcance
 2 - si el identificador de archivo está vacío

Ejemplo asa corta
fhandle = Mmc_Fat_Open ("X_FILES.TXT", FILE_READ,

0x01);
if (Mmc_Fat_Activate (fhandle)) == 0) {
Notas Use la función Mmc_Fat_Open para obtener los

manejadores de archivos.
Mmc_Fat_ReadN
Prototipo unsigned int Mmc_Fat_ReadN ( char *
fdata, unsigned int n);
Descripción Esta función lee múltiples bytes.

Parámetros  fdata: búfer de datos.
 n: Número de bytes para leer.
Devoluciones Número de bytes leídos.

Ejemplo char data_buffer [512];

unsigned int no_bytes;
...
no_bytes = Mmc_Fat_ReadN (& data_buffer, 500);
Notas Ninguna.
Mmc_Fat_Open
Prototipo short Mmc_Fat_Open ( unsigned char *
name, unsigned short mode, char attrib);
Descripción Esta función abre un nuevo archivo.
Parámetros  name: nombre del archivo.

 mode:modo de manejo de
archivos FILE_WRITE, FILE_READo FILE_APPEND.
 attrib:Creación de archivos y banderas de
atributos. Cada bit corresponde al atributo de
archivo apropiado:
0 0x01 Solo lectura
1 0x02 Oculto
2 0x04 Sistema
5 0x20 Archivo

6 0x40

especificado.
Devoluciones  < 0 - si ocurrió un error
 Manejador de archivo para archivo abierto de lo
contrario

Ejemplo asa corta
fhandle = Mmc_Fat_Open ("X_FILES.TXT", FILE_READ,

0x01);
Notas Ninguna.
Mmc_Fat_Close
Prototipo char Mmc_Fat_Close ();
Descripción Esta función cierra el archivo abierto actualmente.
Devoluciones  0 - si el cierre fue exitoso

 1 - si no hay archivos asignados

Ejemplo if (Mmc_Fat_Close () == 0) {
Notas Ninguna.
Mmc_Fat_EOF
Prototipo corto Mmc_Fat_EOF ();
Descripción Esta función comprueba si se llega al final del archivo.
Devoluciones  -1 - si ocurrió un error

 0 - Si no se alcanzó el final del archivo
 1 - si se llegó al final del archivo

Ejemplo if (Mmc_Fat_EOF () == 0) {
}
Notas Ninguna.
El siguiente ejemplo muestra la prueba de la biblioteca MMC. Al destellar, inserte
una tarjeta MMC / SD en el módulo, cuando debería recibir el mensaje "Iniciar-
Aceptar". Luego, puede experimentar con las funciones de lectura y escritura de
MMC y observar los resultados a través de la Terminal de Usart.

sbit Mmc_Chip_Select en LATC0_bit; // para escribir en el pin
de salida siempre use latch (familia
PIC18 ) sbit Mmc_Chip_Select_Direction at TRISC0_bit;
// eof conexiones de módulo MMC
const LINE_LEN = 43;

char err_txt [20] = "FAT16 no encontrado";
char file_contents [LINE_LEN] = "XX MMC / SD FAT16 library de Anton
Rieckertn";
char filename [14] = "MIKRO00x.TXT"; // Nombres de
archivos
sin firmar en bucle corto , loop2;
sin firmar largo i, tamaño;
// UART1 escribe texto y nueva línea (retorno de carro +

salto de línea) void UART1_Write_Line ( char * uart_text) {
UART1_Write_Text (uart_text);
UART1_Write (13);
UART1_Write (10);
}
// Crea un nuevo archivo y escribe algunos datos en él

vacío M_Create_New_File () {
nombre de archivo [7] = 'A';
Mmc_Fat_Set_File_Date (2010, 4, 19, 9, 0, 0); // Establecer información
de fecha y hora del archivo
Mmc_Fat_Assign (& filename, 0xA0); // Encuentra el archivo
Mmc_Fat_Rewrite (); // Para borrar el archivo y
UART1_Write ('.');
Mmc_Fat_Write (file_contents, LINE_LEN-1); // escribir datos en el
archivo asignado
}
}
// Crea muchos archivos nuevos y escribe datos en ellos

void M_Create_Multiple_Files () {
for (loop2 = 'B'; loop2 <= 'Z'; loop2 ++) {
UART1_Write (loop2); // señalizar el
nombre del archivo de progreso [7] = loop2; //
establecer nombre de archivo
Mmc_Fat_Set_File_Date (2010, 4, 19, 9, 0, 0); // Establecer
información de fecha y hora del archivo
Mmc_Fat_Assign (& filename, 0xA0); // encuentra el archivo
Mmc_Fat_Rewrite (); // Para borrar el archivo y
archivo asignado
}
}
}
// Abre un archivo existente y lo vuelve a escribir

void M_Open_File_Rewrite () {
nombre de archivo [7] = 'C';
Mmc_Fat_Assign (& filename, 0);
Mmc_Fat_Rewrite ();
archivo asignado
}
}
// Abre un archivo existente y le agrega datos

// (y altera la marca de fecha / hora)
void M_Open_File_Append () {
Mmc_Fat_Set_File_Date (2010, 4, 19, 9, 20, 0);
Mmc_Fat_Append (); // Preparar
archivo para adjuntar
Mmc_Fat_Write (" para mikroElektronika 2010n", 27); // Escribir datos
}
// Abre un archivo existente, lee los datos y lo coloca en UART

void M_Open_File_Read () {
char character;

Mmc_Fat_Reset (& size); // Para leer el archivo, el
procedimiento devuelve el tamaño del archivo
para (i = 1; i <= tamaño; i ++) {
Mmc_Fat_Read (& carácter);
UART1_Write (carácter); // Escribir datos en UART
}
}
// Borra un archivo. Si el archivo no existe, primero se creará

// y luego borrado.
void M_Delete_File () {
nombre de archivo [7] = 'F';
Mmc_Fat_Assign (nombre de archivo, 0);
Mmc_Fat_Delete ();
}
// Comprueba si el archivo existe, y si es así envía su fecha de creación

// y tamaño de archivo a través de UART
void M_Test_File_Exist () {
unsigned long fsize;
unsigned int año;
mes corto sin firmar , día, hora, minuto;
sin firma char outstr [12];
nombre de archivo [7] = 'B'; // descomentar esta línea para buscar

el archivo que SÍ existe
// nombre de archivo [7] = 'F'; // elimine el comentario de esta línea
para buscar el archivo que NO existe
si (Mmc_Fat_Assign (nombre de archivo, 0)) {
// --- se ha encontrado el archivo - obtenga su fecha de creación
Mmc_Fat_Get_File_Date (& year, & month, & day, & hour, & minute);
UART1_Write_Text ("created:");
// --- se ha encontrado el archivo - obtener su fecha de modificación

Mmc_Fat_Get_File_Date_Modified (& year, & month, & day, & hour, &
minute);
UART1_Write_Text ("modificado:");
// --- obtener el tamaño del archivo

fsize = Mmc_Fat_Get_File_Size ();
LongToStr (( firmado largo ) fsize, outstr);
UART1_Write_Line (outstr);
}
else {
// --- no se encontró el archivo - señalalo
UART1_Write (0x55);
Delay_ms (1000);
UART1_Write (0x55);
}
}
// Intenta crear un archivo de intercambio, cuyo tamaño será de al menos

100
// sectores (consulte la Ayuda para obtener más información)
unsigned int i;
para (i = 0; i <512; i ++)

Tampón [i] = i;
tamaño = Mmc_Fat_Get_Swap_File (5000, "mikroE.txt", 0x20); // vea la

ayuda en esta función para más detalles
si (tamaño) {
LongToStr (( firmado largo ) tamaño, err_txt);
UART1_Write_Line (err_txt);
para (i = 0; i <5000; i ++) {

Mmc_Write_Sector (size ++, Buffer);
UART1_Write ('.');
}
}
}
// Principal. Descomente las funciones para probar la (s) operación (es)

deseada (s)
void main () {
#define COMPLETE_EXAMPLE // comente esta línea para simplificar
/
reducir el ejemplo ADCON1 | = 0x0F; // Configurar los
pines AN como
CMCON digital = = 7; // apagar los comparadores
// Inicializar módulo UART1

UART1_Init (19200);
Delay_ms (10);
UART1_Write_Line ("PIC-Started"); // presente informe PIC
// Inicializar el módulo SPI1

SPI1_Init_Advanced (_SPI_MASTER_OSC_DIV64, _SPI_DATA_SAMPLE_MIDDLE,
_SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
// use el formato rápido fat16 en lugar de la rutina init si se necesita

un formato
si (Mmc_Fat_Init () == 0) {
// reinicializar spi a mayor velocidad
SPI1_Init_Advanced (_SPI_MASTER_OSC_DIV4, _SPI_DATA_SAMPLE_MIDDLE,
_SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
// --- Inicio de prueba
UART1_Write_Line ("Test Start.");
// --- Rutinas de prueba. Descoméntelos uno por uno para probar
ciertas características
M_Create_New_File ();
M_Create_Multiple_Files ();
M_Open_File_Rewrite ();
M_Open_File_Append ();
M_Open_File_Read ();
M_Delete_File ();
M_Test_File_Exist ();
M_Create_Swap_File ();
#terminara si
UART1_Write_Line ("Test End.");
}
else {
UART1_Write_Line (err_txt); // Nota: Mmc_Fat_Init intenta inicializar
una tarjeta más de una vez.
// Si la tarjeta no está presente, la
inicialización puede durar más (dependiendo de la velocidad del reloj)
}
Conexión HW
Interfaz MMC
Biblioteca OneWire
La biblioteca OneWire proporciona rutinas para la comunicación a través del
protocolo Dallas OneWire, por ejemplo, con el termómetro digital
DS18x20. OneWire es un protocolo maestro / esclavo, y todo el cableado de
comunicación requerido es un solo cable. Los dispositivos habilitados para OneWire
deben tener controladores de colector abiertos (con resistencia de extracción única)
en la línea de datos compartida.
Los dispositivos esclavos en el bus OneWire pueden incluso obtener su fuente de
alimentación de la línea de datos. Para un esquema detallado vea la hoja de datos
del dispositivo.
Algunas características básicas de este protocolo son:
 sistema maestro único,
 bajo costo,
 bajas tasas de transferencia (hasta 16 kbps),
 distancias bastante largas (hasta 300 metros),
 pequeños paquetes de transferencia de datos.
Cada dispositivo OneWire también tiene un número de registro único de 64 bits
(tipo de dispositivo de 8 bits, número de serie de 48 bits y CRC de 8 bits), por lo
que pueden coexistir múltiples esclavos en el mismo bus.
Importante:
 Frecuencia del oscilador Fosc debe ser de al menos 4 MHz para poder
utilizar las rutinas con termómetros digitales de Dallas.
 Esta biblioteca implementa actividades basadas en el tiempo, por lo que
las interrupciones deben deshabilitarse cuando se utiliza la biblioteca
OneWire.
 Ow_Reset
 Ow_Read
 Ow_Write
Ow_Reset
Prototipo Ow_Reset corto sin firmar ( puerto short * sin
firmar , pin corto sin firmar );
Devoluciones  0 si el dispositivo esta presente

 1 si el dispositivo no está presente
Descripción Emite la señal de reinicio de OneWire para DS18x20.

Parámetros:
 port: Puerto de bus OneWire
 pin: Pin bus oneWire
Requiere Dispositivos compatibles con el protocolo Dallas OneWire.
Ejemplo Para restablecer el DS1820 que está conectado al pin RE2:

Ow_Reset (& PORTE, 2);
Ow_Read
Prototipo Ow_Read corto sin firmar ( puerto short * sin
firmar , pin corto sin firmar );
Devoluciones Lectura de datos desde un dispositivo externo a través del

bus OneWire.
Descripción Lee un byte de datos a través del bus OneWire.

Parámetros:
Ejemplo // Leer un byte del

tmp corto sin firmar de One-Wire Bus ;
...
tmp = Ow_Read (& PORTE, 2);
Ow_Write
Prototipo void Ow_Write ( puerto corto * sin signo ,
pin corto sin signo , par corto sin signo );
Devoluciones Nada.
Descripción Escribe un byte de datos a través del bus OneWire.

Parámetros:
 par: datos a escribir
Ejemplo // Enviar un byte al Bus de un cable

Ow_Write (& PORTE, 2, 0xCC);
Este ejemplo lee la temperatura usando DS18x20 conectado al pin
PORTE.B2. Después del reinicio, la MCU obtiene la temperatura del sensor y la
imprime en el Lcd. Asegúrese de levantar la línea PORTE.B2 y de apagar los LEDs
PORTE.


// Establezca TEMP_RESOLUTION en la resolución correspondiente del sensor

DS18x20 usado:
// 18S20: 9 (configuración predeterminada; puede ser 9,10,11 o 12)
// 18B20: 12
const sin signo TEMP_RESOLUTION corto = 9;
char * text = "000.0000";

temperatura sin firmar
void Display_Temperature ( unsigned int temp2write) {

const unsigned short RES_SHIFT = TEMP_RESOLUTION - 8;
char temp_whole;
unsigned int temp_fraction;
// Compruebe si la temperatura es negativa

si (temp2write y 0x8000) {
texto [0] = '-';
temp2write = ~ temp2write + 1;
}
// Extraer temp_whole
temp_whole = temp2write >> RES_SHIFT;
// Convertir temp_whole en caracteres

if (temp_whole / 100)
texto [0] = temp_whole / 100 + 48;
más
texto [0] = '0';
texto [1] = (temp_whole / 10)% 10 + 48; // Extraiga el

texto de diez dígitos [2] = temp_whole% 10 + 48; // Extraer
los dígitos
// Extraer temp_fraction y convertirlo en int sin signo

temp_fraction = temp2write << (4-RES_SHIFT);
temp_fraction & = 0x000F;
temp_fraction * = 625;
// Convertir temp_fraction en
texto de caracteres [4] = temp_fraction / 1000 + 48; // Extraer
texto de miles de dígitos [5] = (temp_fraction / 100)% 10 + 48;
// Extraer
texto de cientos de dígitos [6] = (temp_fraction / 10)% 10 + 48;
// Extrae el
texto de decenas de dígitos [7] = temp_fraction% 10 + 48; //
Extraer los dígitos
// Temperatura de impresión en LCD

Lcd_Out (2, 5, texto);
}
void main () {
ANSEL = 0; // Configurar pines AN
como E / S digital
ANSELH = 0;
comparadores
C2ON_bit = 0;

Lcd_Cmd (_LCD_CLEAR); // Borrar LCD
Lcd_Cmd (_LCD_CURSOR_OFF); // apagar el cursor
Lcd_Out (1, 1, "Temperature:");
// Imprimir carácter de grado, 'C' para Centígrados
Lcd_Chr (2,13,223); // Las diferentes
pantallas LCD tienen diferentes códigos de caracteres para el grado
// Si ve una letra alfa
griega, intente escribir 178 en lugar de 223
Lcd_Chr (2,14, 'C');
// ---
Circuito principal do {
// --- Realizar la lectura de temperatura Ow_Reset (& PORTE, 2);
// señal de reinicio de
Onewire Ow_Write (& PORTE, 2, 0xCC); // Ejecute el
comando SKIP_ROM
Ow_Write (& PORTE, 2, 0x44); // comando de comando
CONVERT_T
Delay_us (120);
Ow_Reset (& PORTE, 2);

Ow_Write (& PORTE, 2, 0xCC); // Ejecute el comando
SKIP_ROM
Ow_Write (& PORTE, 2, 0xBE); // comando de comando
READ_SCRATCHPAD
temp = Ow_Read (& PORTE, 2);

temp = (Ow_Read (& PORTE, 2) << 8) + temp;
// --- Formato y visualización del resultado en Lcd

Display_Temperature (temp);
Delay_ms (500);
} while (1);
}
Conexión HW
Ejemplo de conexión DS1820
Pin Select Peripheral Library
La biblioteca de selección de pin periférico permite la reasignación de periféricos en
los siguientes MCU: 18F2xJ11, 18F4xJ11, 18F2xJ50 y 18F4xJ50.
Una diferencia clave entre los periféricos de selección de pin y los que no lo son es
que los periféricos de selección de pin no están asociados con un pin de E / S
predeterminado.
El periférico siempre debe asignarse a un pin de E / S específico antes de poder
utilizarlo. En contraste, los periféricos no seleccionables por pin siempre están
disponibles en un pin predeterminado, asumiendo que el periférico está activo y no
está en conflicto con otro periférico.
 Desbloquear_IOLOCK
 Lock_IOLOCK
 PPS_Mapping
 PPS_Mapping_NoLock
Desbloquear_IOLOCK
Prototipo void Unlock_IOLOCK ();
Devoluciones Nada.
Descripción Desbloquea los pines de E / S para la asignación de pines

periféricos.
Requiere Nada.
Ejemplo Unlock_IOLOCK ();
Lock_IOLOCK
Prototipo void Lock_IOLOCK ();
Devoluciones Nada.
Descripción Bloquea los pines de E / S para la asignación de pines

periféricos.
Requiere Nada.
Ejemplo Lock_IOLOCK ();
PPS_Mapping
Prototipo char PPS_Mapping
( char rp_num, char input_output, char funct_name)
;
Devolucione  0 - Si el mapeo de pines periféricos no tuvo

s éxito.
 255 - Si la asignación de pines periféricos fue
exitosa.
Descripción Establece el módulo interno deseado de MCU para ser

mapeado con los pines solicitados.
Parámetros:
 rp_num: Número de pin extraíble. Consulte la
hoja de datos correspondiente para los valores
adecuados.
 input_output: Establece el pin solicitado para
ser usado como entrada o salida.
 funct_name: Selecciona el módulo MCU interno
para su uso.
Requiere Nada.
Ejemplo PPS_Mapping (15, _INPUT, _RX2_DT2); // Establece el

pin 15 como entrada, y asigna la entrada RX2 / DT2 a
PPS_Mapping (5, _OUTPUT, _TX2_CK2); // Establece el
pin 5 como salida, y le asigna a EUSART2 Transmisión
asíncrona / Salida de reloj síncrona
PPS_Mapping_NoLock
Prototipo char PPS_Mapping_NoLock
( char rp_num, char input_output, char funct_name)
;
Devolucione  0 - Si el mapeo de pines periféricos no tuvo

s éxito.
 255 - Si la asignación de pines periféricos fue
exitosa.
Descripción Establece el módulo interno deseado de MCU para ser

mapeado en los pines solicitados.
Esta función no utiliza
las rutinas Unlock_IOLOCK y Lock_IOLOCK , por lo
que el usuario debe llamarlas antes y después de esta
función (muy útil si IOL1WAYse establece el bit, cuando
después de una secuencia de bloqueo no es posible
desbloquearla).
Parámetros:
 rp_num: Número de pin extraíble. Consulte la
hoja de datos correspondiente para los valores
adecuados.
 input_output: Establece el pin solicitado para
ser usado como entrada o salida.
 funct_name: Selecciona el módulo MCU interno
para su uso.
Parámetros
Requiere Nada.
Ejemplo Desbloquear_IOLOCK ()
PPS_Mapping_NoLock (15, _INPUT, _RX2_DT2); //
Establece el pin 15 como entrada, y asigna la entrada
RX2 / DT2 a
PPS_Mapping_NoLock (5, _OUTPUT, _TX2_CK2); //
Establece el pin 5 como salida, y le asigna a EUSART2
Transmisión asíncrona / Salida de reloj síncrona
Lock_IOLOCK ()
Parámetros disponibles
Nombre de la función Descripción
(entrada)
_INT1 Interrupción externa 1
_T0CKI Timer0 Entrada de reloj externo
_T3CKI Timer3 Entrada de reloj externo
_CCP1 Captura de entrada 1
_CCP2 Captura de entrada 2
_T1G Entrada de puerta Timer1
_T3G Entrada de puerta Timer3
_RX2_DT2 Entrada RX2 / DT2
_CK2 EUSART2 entrada de reloj síncrono
_SDI2 Entrada de datos SPI2
_SCK2IN Entrada de reloj SPI2
_SS2IN Entrada de selección de esclavo SPI2
_FLT0 Entrada de fallo de PWM

(salida)
_NULO La función NULL se asigna a todas las salidas RPn en el reinicio del
dispositivo y desactiva la función de salida RPn.
(entrada)
_C1OUT Comparador 1 salida
_C2OUT Comparador 2 de salida
_TX2_CK2 EUSART2 Transmisión asíncrona / Salida de reloj síncrono
_DT2 Transmisión Sincrónica EUSART2
_SDO2 Salida de datos SPI2
_SCK2 Salida de reloj SPI2
_SSDMA SPI DMA Slave Select
_ULPOUT Evento de despertador de ultra bajo consumo
_CCP1_P1A ECCP1 Compare o PWM Canal de salida A
_P1B Salida PCP mejorada de ECCP1, canal B
_P1C ECCP1 salida PWM mejorada, canal C
_P1D ECCP1 salida PWM mejorada, canal D
_CCP2_P2A ECCP2 Comparar o Salida PWM
_P2B ECCP2 salida PWM mejorada, canal B
_P2C ECCP2 salida PWM mejorada, canal C
_P2D ECCP2 salida PWM mejorada, canal D
Parámetro de entrada Descripción

/ salida
_ENTRADA Establece el pin seleccionado como entrada
_SALIDA Establece el pin seleccionado como salida
Biblioteca de Puerto Expander

El mikroC PRO para PIC proporciona una biblioteca para la comunicación con el
puerto de expansión MCP23S17 del Microchip a través de la interfaz SPI . Las
conexiones de MCU y MCP23S17 compatibles con PIC se encuentran en el esquema
al final de esta página.
Importante:
inicializar el módulo SPI apropiado antes de usar la biblioteca de Port
Expander.
 La biblioteca no utiliza las interrupciones de Port Expander.
Dependencias externas de Port Expander Library

Las siguientes
variables deben
Descripci
ón:
proyectos usando Port
Expander Library:
extern sfr Restablece sbit SPExpanderRST atRC0_bit;
sbitSPExpanderRST; r línea.
Chip de
extern sfr
sbitSPExpanderCS; selección sbit SPExpanderCS atRC1_bit;
de línea.

sbitSPExpanderRST_Direction at TRI
sbitSPExpanderRST_Direc del pin de SC0_bit;
tion; reinicio.
Dirección
extern sfr
sbitSPExpanderCS_Direct del pin sbitSPExpanderCS_Direction at TRIS
ion; Chip C1_bit;
Select.
 Expander_Init
 Expander_Init_Advanced
 Expander_Read_Byte
 Expander_Write_Byte
 Expander_Read_PortA
 Expander_Read_PortB
 Expander_Read_PortAB
 Expander_Write_PortA
 Expander_Write_PortB
 Expander_Write_PortAB
 Expander_Set_DirectionPortA
 Expander_Set_DirectionPortB
 Expander_Set_DirectionPortAB
 Expander_Set_PullUpsPortA
 Expander_Set_PullUpsPortB
 Expander_Set_PullUpsPortAB
Expander_Init
Prototipo void Expander_Init ( char ModuleAddress);
Devoluciones Nada.
Descripción Inicializa Port Expander utilizando la comunicación SPI.

Configuración del módulo de puerto expansor:
 direccionamiento de hardware habilitado
 Incremento automático del puntero de
dirección deshabilitado (modo byte)
 BANK_0 registrar direcciones
 velocidad de respuesta habilitada
Parámetros:
 ModuleAddress: Dirección de hardware de Port
Expander, vea el esquema al final de esta
página

 SPExpanderCS: Línea Chip Select
 SPExpanderRST: Restablecer línea
 SPExpanderCS_Direction: Dirección del pin
Chip Select
 SPExpanderRST_Direction: Dirección del pin de
reinicio

Ejemplo // Conexiones del módulo Port Expander

sbit SPExpanderRST en RC0_bit;
sbit SPExpanderCS en RC1_bit;
sbit SPExpanderRST_Direction en TRISC0_bit;
sbit SPExpanderCS_Direction en TRISC1_bit;
// Terminar las conexiones del módulo expansor de
puertos
...
ANSEL = 0; // Configurar pines AN como

E / S digital
ANSELH = 0;
// Si Port Expander Library usa el módulo SPI

SPI1_Init (); // Inicializar el módulo
SPI utilizado con PortExpander
Expander_Init (0); // Inicializar Port
Expander
Expander_Init_Advanced
Prototipo void Expander_Init_Advanced ( char *
rstPort, char rstPin, char haen);
Devoluciones Nada.
Descripción Inicializa Port Expander utilizando la comunicación SPI.

Parámetros:
 rstPort: Puerto de reinicio del expansor de
puertos
 rstPin: Pin de reinicio del expansor de puerto
 haen:Habilitar el direccionamiento de
hardware. Valores válidos:
 0 - direccionamiento de hardware
deshabilitado
 1 - dirección de hardware
habilitada
Requiere  SPExpanderCS: Línea Chip Select

Chip Select
reinicio


puertos
...
ANSEL = 0; // Configurar pines AN como

E / S digital
ANSELH = 0;
// Si Port Expander Library usa el módulo SPI

SPI utilizado con PortExpander
Expander_Init_Advanced (& PORTB, 0, 0); //
Inicializar Port Expander
Expander_Read_Byte
Prototipo char Expander_Read_Byte
( char ModuleAddress, char RegAddress);
Devoluciones Byte leer.
Descripción La función lee el byte de Port Expander.

Parámetros:
página
 RegAddress: Dirección interna de registro de
Port Expander
Requiere Port Expander debe estar inicializado. Ver Expander_Init .
Ejemplo // Leer un byte del registro de Port Expander

char read_data;
...
read_data = Expander_Read_Byte (0,1);
Expander_Write_Byte
Prototipo void Expander_Write_Byte
( char ModuleAddress, char RegAddress, char Data);
Devoluciones Nada.
Descripción La rutina escribe un byte en Port Expander.

Parámetros:
página
 RegAddress: Dirección interna de registro de
Port Expander
 Data_: datos a escribir
Ejemplo // Escribir un byte en el registro del expansor de

puertos.
Expander_Write_Byte (0,1,0xFF);
Expander_Read_PortA
Prototipo char Expander_Read_PortA ( char ModuleAddress);
Devolucio Byte leer.

nes
Descripció La función lee el byte del puerto A del expansor de puertos.

n Parámetros:
Expander, vea el esquema al final de esta página

El puerto A del puerto de expansión debe configurarse como
entrada. Ver
las rutinas Expander_Set_DirectionPortA y Expander_Set_Dir
ectionPortAB .
Ejemplo // Leer un byte de PORTA del Port Expander

char read_data;
...
Expander_Set_DirectionPortA (0,0xFF); //
establece el porta del expansor como entrada
...
read_data = Expander_Read_PortA (0);
Expander_Read_PortB
Prototipo char Expander_Read_PortB ( char ModuleAddress);
Devolucio Byte leer.

nes
Descripció La función lee el byte del PortBort de Port Expander.
n Parámetros:

El puerto de expansión del puerto debe estar configurado
como entrada. Ver
las rutinas Expander_Set_DirectionPortB y Expander_Set_Dir
ectionPortAB .
Ejemplo // Leer un byte de PORTB de expansión del puerto de

carbón read_data;
...
Expander_Set_DirectionPortB (0,0xFF); //
establece el portb del expansor como entrada
...
read_data = Expander_Read_PortB (0);
Expander_Read_PortAB
Prototip unsigned int Expander_Read_PortAB
o ( char ModuleAddress);
Devoluc Palabra leída

iones
Descrip La función lee la palabra de los puertos de Port Expander. Las

ción lecturas de PortA están en el byte más alto del resultado. Las
lecturas de PortB están en el byte inferior del resultado.
Parámetros:
Requier Port Expander debe estar inicializado. Ver Expander_Init .

e Los puertos A y PortB del expansor de puertos deben
configurarse como entradas. Consulte
las rutinas Expander_Set_DirectionPortA , Expander_Set_Directio
nPortB y Expander_Set_DirectionPortAB .
Ejemplo // Leer un byte de Port Expander PORTA y PORTB

unsigned int read_data;
...
Expander_Set_DirectionPortAB (0,0xFFFF); //
configura el porta y el portb del expansor como entrada
...
read_data = Expander_Read_PortAB (0);
Expander_Write_PortA
Prototipo void Expander_Write_PortA
( char ModuleAddress, char Data_);
Devolucio Nada.
nes
Descripció La función escribe byte en el puerto A del expansor de
n puertos.
Parámetros:

El puerto A de Port Expander debe configurarse como
salida. Ver
las rutinas Expander_Set_DirectionPortA y Expander_Set_Dir
ectionPortAB .
Ejemplo // Escribir un byte en el PORTA del expansor de

puertos.
...
Expander_Set_DirectionPortA (0,0x00); //
configura el porta del expansor para que salga
...
Expander_Write_PortA (0, 0xAA);
Expander_Write_PortB
Prototipo void Expander_Write_PortB
Devolucio Nada.
nes
Descripció La función escribe byte en el PortBort de Port Expander.

n Parámetros:

El PortBort de Port Expander debe configurarse como
salida. Ver
las rutinas Expander_Set_DirectionPortB y Expander_Set_Dir
ectionPortAB .
Ejemplo // Escribir un byte al PORTB del expansor de puertos
...
Expander_Set_DirectionPortB (0,0x00); //
establece el portb del expansor como salida
...
Expander_Write_PortB (0, 0x55);
Expander_Write_PortAB
Prototip void Expander_Write_PortAB
o ( char ModuleAddress, unsigned int Data_);
Devoluc Nada.
iones
Descrip La función escribe la palabra en los puertos de Port Expander.

ción Parámetros:
 Data_:Datos a escribir. Los datos que se escribirán
en PortA se pasan en Datael byte superior. Los datos
que se escriben en PortB se pasan en Datael byte
inferior
Requier Port Expander debe estar inicializado. Ver Expander_Init .

e Los puertos A y PortB del expansor de puertos deben
configurarse como salidas. Consulte
las rutinas Expander_Set_DirectionPortA , Expander_Set_Directio
nPortB y Expander_Set_DirectionPortAB .
Ejemplo // Escribir un byte a PORTA y PORTB de Port Expander
...
Expander_Set_DirectionPortAB (0,0x0000); //
configura el porta y el portb del expansor para que
salgan
...
Expander_Write_PortAB (0, 0xAA55);
Expander_Set_DirectionPortA
Prototipo void Expander_Set_DirectionPortA
( char ModuleAddress, charData_);
Devoluciones Nada.
Descripción La función establece la dirección PortA del Port Expander.

Parámetros:
página
 Data_:Datos a escribir en el registro de
dirección del puerto. Cada bit corresponde al
pin apropiado del registro PortA. Establecer bit
designa el pin correspondiente como
entrada. El bit borrado designa el pin
correspondiente como salida.
Ejemplo // Configurar la PORTA del expansor de puertos como

salida
Expander_Set_DirectionPortA (0,0x00);
Expander_Set_DirectionPortB
Prototipo void Expander_Set_DirectionPortB
( char ModuleAddress, charData_);
Devoluciones Nada.
Descripción La función establece la dirección del puerto de Port

Expander.
Parámetros:
página
 Data_:Datos a escribir en el registro de
dirección del puerto. Cada bit corresponde al
pin apropiado del registro PortB. Establecer bit
designa el pin correspondiente como
entrada. El bit borrado designa el pin
correspondiente como salida.
Ejemplo // Establecer el PORTB del expansor de puertos como

entrada
Expander_Set_DirectionPortB (0,0xFF);
Expander_Set_DirectionPortAB
Prototipo void Expander_Set_DirectionPortAB
( char ModuleAddress, unsigned intDirection);
Devoluciones Nada.
Descripción La función establece la dirección PortA y PortB de Port

Expander.
Parámetros:
página
 Direction:Datos a escribir en registros de
dirección. Los datos que se escribirán en el
registro de dirección del puerto A se pasan
en Directionel byte más alto. Los datos que se
escribirán en el registro de dirección PortB se
pasan en Directionel byte inferior. Cada bit
corresponde al pin apropiado del registro PortA
/ PortB. Establecer bit designa el pin
correspondiente como entrada. El bit borrado
designa el pin correspondiente como salida.
Ejemplo // Configurar la PORTA del expansor de puertos como

salida y PORTB como entrada
Expander_Set_DirectionPortAB (0,0x00FF);
Expander_Set_PullUpsPortA
Prototipo void Expander_Set_PullUpsPortA
Devoluciones Nada.
Descripción La función configura las resistencias de subida / bajada de

PortA de Port Expander.
Parámetros:
página
 Data_:Datos para elegir la configuración de
resistencias pull up / down. Cada bit
corresponde al pin apropiado del registro
PortA. El bit de ajuste habilita el pull-up para el
pin correspondiente.
Ejemplo // Establecer las resistencias pull-up PORTA de Port

Expander
Expander_Set_PullUpsPortA (0, 0xFF);
Expander_Set_PullUpsPortB
Prototipo void Expander_Set_PullUpsPortB
Devoluciones Nada.

PortBort Portbander.
Parámetros:
página
 Data_:Datos para elegir la configuración de
resistencias pull up / down. Cada bit
corresponde al pin apropiado del registro
PortB. El bit de ajuste habilita el arranque para
el pin correspondiente.
Ejemplo // Establecer las resistencias de pull-up PORTBander

Expander_Set_PullUpsPortB (0, 0xFF);
Expander_Set_PullUpsPortAB
Prototipo void Expander_Set_PullUpsPortAB
( char ModuleAddress, unsigned intPullUps);
Devoluciones Nada.

PortA y PortB de Port Expander.
Parámetros:
página
 PullUps:Datos para elegir la configuración de
resistencias pull up / down. La configuración de
las resistencias de subida / bajada del puerto A
se pasa en PullUpsel byte más alto. La
configuración de las resistencias de subida /
bajada de PortB se pasa en PullUpsel byte
inferior. Cada bit corresponde al pin apropiado
del registro PortA / PortB. El bit de ajuste
habilita el pull-up para el pin correspondiente.
Ejemplo // Establecer las resistencias pull-up PORTA y PORTB

de Port Expander
Expander_Set_PullUpsPortAB (0, 0xFFFF);
El ejemplo muestra cómo comunicarse con Port Expander MCP23S17.
Tenga en cuenta que los pines A2 A1 A0 del expansor de puertos están conectados
a GND, por lo que la dirección del hardware del expansor de puertos es 0.
// Conexiones del módulo Port Expander

// Terminar las conexiones del módulo expansor de puertos
carácter sin firma i = 0;
void main () {
digital
ANSELH = 0;
C2ON_bit = 0;
TRISB = 0; // Establecer PORTB como salida

PORTB = 0xFF;
// Si Port Expander Library usa el módulo SPI1

SPI usado con PortExpander
// Si Port Expander Library utiliza el módulo SPI2

// SPI2_Init (); // Inicializar el módulo SPI usado con PortExpander
Expander_Init (0); // Inicializar Port Expander

Expander_Set_DirectionPortA (0, 0x00); // Establecer la PORTA del
expansor para que sea la salida
Expander_Set_DirectionPortB (0,0xFF); // Establecer el PORTB del

expansor para que sea ingresado
Expander_Set_PullUpsPortB (0,0xFF); // Establezca pull-ups para
todos los pines PORTB del expansor

Expander_Write_PortA (0, i ++); // Escribe i en el PORTA
PORTB = Expander_Read_PortB (0); // Lee el PORTB del expansor y
escríbelo en los LED
Delay_ms (100);
}
Conexión HW
Conexión de puerto Expander HW
Biblioteca PS / 2
El mikroC PRO para PIC proporciona una biblioteca para la comunicación con el
teclado PS / 2 común.
Importante:
 La biblioteca no utiliza interrupciones para la recuperación de datos, y
requiere que el reloj del oscilador sea al menos de 6MHz.
 Los pines a los que está conectado un teclado PS / 2 deben estar
conectados a las resistencias de pull-up.
 Aunque PS / 2 es un bus de comunicación de dos vías, esta biblioteca
no proporciona comunicación de MCU a teclado; Por ejemplo, al
presionar la Caps Lock tecla no se encenderá el LED de Bloqueo de
mayúsculas.
Dependencias externas de la biblioteca PS / 2
Las siguientes
variables deben
Descripció
n:
proyectos usando la
Biblioteca PS / 2:
Línea de
extern sfr
sbit PS2_Data; datos PS / sbit PS2_Data atRC0_bit;
2.
extern sfr PS / 2 línea

sbit PS2_Clock atRC1_bit;
sbitPS2_Clock; de reloj.
Dirección
extern sfr
del pin de sbitPS2_Data_Direction at TRISC0_b
sbitPS2_Data_Direction
; datos PS / it;
2.

sbitPS2_Clock_Direction at TRISC1_
sbitPS2_Clock_Directio del pin reloj bit;
n; PS / 2.
 Ps2_Config
 Ps2_Key_Read
Ps2_Config
Prototipo void Ps2_Config ();
Devoluciones Nada.
Descripción Inicializa la MCU para trabajar con el teclado PS / 2.

 PS2_Data: Línea de señal de datos
 PS2_Clock: Línea de señal de reloj en
 PS2_Data_Direction: Dirección del pin de
datos
 PS2_Clock_Direction: Dirección del pin del
reloj
Ejemplo sbit PS2_Data en RC0_bit;

sbit PS2_Clock at RC1_bit;
sbit PS2_Data_Direction at TRISC0_bit;
sbit PS2_Clock_Direction en TRISC1_bit;
...
Ps2_Config (); // Inicia el teclado PS / 2
Ps2_Key_Read
Prototipo Ps2_Key_Read corto sin firmar ( valor short * sin
firmar , short * sin firmar * special, short * sin
firmar pulsado);
Devoluciones  1 Si la lectura de una tecla desde el teclado fue

exitosa.
 0 si no se presionó ninguna tecla
Descripción La función recupera información sobre la tecla pulsada.

Parámetros:
 value:Mantiene el valor de la tecla
presionada. Para caracteres, números, signos
de puntuación y espacio valuese almacenará
el código ASCII apropiado . La rutina
"reconoce" la función de Shift y Caps Lock , y se
comporta de manera apropiada. Para las teclas
de funciones especiales, consulte la Tabla
de teclas de funciones especiales .
 special: es una bandera para las teclas de
función especiales ( F1 , Enter , Esc , etc.). Si la
tecla presionada es una de estas, specialse
establecerá en 1, de lo contrario 0.
 pressed: se establece en 1 si se presiona la
tecla y 0 si se suelta.
Requiere Se debe inicializar el teclado PS / 2. Ver

la rutina Ps2_Config .
Ejemplo keydata corto sin signo = 0, especial = 0, abajo =

0;
...
// Presione Entrar para continuar:
do {
if (Ps2_Key_Read (& keydata, & special, & down))
{
if (down && (keydata == 16)) break ;
}
} while (1);
Teclas de función especial
Llave Valor
devuelto
F1 1
F2 2
F3 3
F4 4
F5 5
F6 6
F7 7
F8 8
F9 9
F10 10
F11 11
F12 12
Entrar 13
Página arriba 14
Página abajo 15
Retroceso dieciséis
Insertar 17
Borrar 18
Windows 19
Ctrl 20
Cambio 21
Alt 22
Imprimir pantalla 23
Llave Valor
devuelto
Pausa 24
Bloq Mayús 25
Fin 26
Casa 27
Bloqueo de desplazamiento 28
Num lock 29
Flecha izquierda 30
Flecha correcta 31
Flecha arriba 32
Flecha hacia abajo 33
Escapar 34
Lengüeta 35
Este sencillo ejemplo lee los valores de las teclas presionadas en el teclado PS / 2 y
las envía a través de UART .
keydata corto sin signo = 0, especial = 0, abajo = 0;
sbit PS2_Data en RC0_bit;

sbit PS2_Clock at RC1_bit;
sbit PS2_Data_Direction at TRISC0_bit;
sbit PS2_Clock_Direction en TRISC1_bit;
void main () {
ANSEL = 0; // Configurar pines

AN como E / S digital
ANSELH = 0;
comparadores
C2ON_bit = 0;
UART1_Init (19200); // Inicializar el

módulo UART a 19200 bps
Ps2_Config (); // Init PS / 2
Keyboard
Delay_ms (100); // Espera a que el
teclado termine
UART1_Write_Text ("Listo");
UART1_Write (10); // Line Feed
UART1_Write (13); // retorno de carro
do {
if (Ps2_Key_Read (& keydata, & special, & down)) {
if (down && (keydata == 16)) { // Retroceso
UART1_Write (0x08);
}
else if (down && (keydata == 13)) { // Ingrese
UART1_Write ('r'); // enviar retorno de
carro a usart terminal
// Usart_Write ('n'); // elimine el comentario de esta línea si
usart terminal también espera un salto de línea
// para la nueva
transición de línea
}
else if (abajo &&! special && keydata) {
UART1_Write (keydata);
}
}
Delay_ms (1); // debounce
} while (1);
}
Conexión HW
Ejemplo de conexión de teclado PS2

Biblioteca de PWM
El módulo CCP está disponible con una serie de MCU PIC. mikroC PRO for PIC
proporciona una biblioteca que simplifica el uso del módulo PWM HW.
Importante:
 Algunas MCU tienen múltiples módulos CCP . Para utilizar la rutina de
biblioteca CCPdeseada , simplemente cambie el número 1en el prototipo
con el número de módulo apropiado, es decir PWM2_Start();.
 Todos los módulos PWM utilizan Timer2 para su funcionamiento, por lo
que no puede configurar diferentes frecuencias para
diferentes módulos PWM .
 PWM1_Init
 PWM1_Set_Duty
 PWM1_Start
 PWM1_Stop
PWM1_Init
Prototipo void PWM1_Init ( const long freq);
Devoluciones Nada.
Descripción Inicializa el módulo PWM con relación de trabajo 0. El

parámetro freqes una frecuencia PWM deseada en Hz
(consulte la hoja de datos del dispositivo para conocer los
valores correctos con respecto a Fosc).
Se debe llamar a esta rutina antes de usar otras funciones
de la Biblioteca PWM .
Requiere MCU debe tener módulo CCP .
Nota: El compilador lleva a cabo el cálculo del valor

de la frecuencia PWM, ya que produciría un código
relativamente grande si se realiza en el nivel de la
biblioteca.
Por lo tanto, el compilador necesita saber el valor del
parámetro en el tiempo de compilación. Es por eso que
este parámetro debe ser una constante, y no una variable.
Ejemplo Inicialice el módulo PWM a 5KHz:

PWM1_Init (5000);
PWM1_Set_Duty
Prototipo void PWM1_Set_Duty ( unsutyed short duty_ratio);
Devoluciones Nada.
Descripción Establece la relación de trabajo PWM . El

parámetro dutytoma valores de 0 a 255, donde 0 es 0%,
127 es 50% y 255 es 100% de tasa de trabajo. Otros
valores específicos para la relación de trabajo se pueden
calcular como (Percent*255)/100.
Requiere MCU debe tener módulo CCP . Se debe llamar
a PWM1_Init antes de usar esta rutina.
Ejemplo Establecer la relación de trabajo al 75%:

PWM1_Set_Duty (192);
PWM1_Start
Prototipo void PWM1_Start ( void );
Devoluciones Nada.
Descripción Inicia PWM .

a PWM1_Init antes de usar esta rutina.
Ejemplo PWM1_Start ();
PWM1_Stop
Prototipo void PWM1_Stop ( void );
Devoluciones Nada.
Descripción Se detiene PWM .

a PWM1_Init antes de usar esta rutina. Se debe llamar
a PWM1_Start antes de usar esta rutina, de lo contrario no
tendrá ningún efecto ya que el módulo PWM no se está
ejecutando.
Ejemplo PWM1_Stop ();
El ejemplo cambia la relación de trabajo PWM en los pines RC1 y RC2
continuamente. Si el LED está conectado a estos pines, puede observar el cambio
gradual de la luz emitida.
unsigned short current_duty, old_duty, current_duty1, old_duty1;
void InitMain () {
ANSELH = 0;
C2ON_bit = 0;
PORTA = 255;
TRISA = 255; // configura los pines PORTA como
entrada
PORTB = 0; // establece PORTB en 0
TRISB = 0; // designar pines PORTB como salida
PORTC = 0; // establece PORTC en 0
TRISC = 0; // designar los pines PORTC como
salida
PWM1_Init (5000); // Inicializar el módulo PWM1 a
5KHz
PWM2_Init (5000); // Inicializar el módulo PWM2 a
5KHz
}
void main () {
InitMain ();
current_duty = 16; // valor inicial para current_duty
current_duty1 = 16; // valor inicial para current_duty1
PWM1_Start (); // iniciar PWM1

PWM2_Start (); // iniciar PWM2
PWM1_Set_Duty (current_duty); // Establecer el servicio actual
para PWM1
PWM2_Set_Duty (current_duty1); // Establecer el servicio actual
para PWM2
while (1) { // bucle sin fin

si (RA0_bit) { // botón en RA0 presionado
Delay_ms (40);
current_duty ++; // incrementa current_duty
PWM1_Set_Duty (current_duty);
}
si (RA1_bit) { // botón en RA1 presionado

Delay_ms (40);
current_duty--; // decrement current_duty
PWM1_Set_Duty (current_duty);
}
botón if (RA2_bit) { // en RA2 presionado

Delay_ms (40);
current_duty1 ++; // incrementar current_duty1
PWM2_Set_Duty (current_duty1);
}
botón if (RA3_bit) { // en RA3 presionado

Delay_ms (40);
current_duty1--; // decrement current_duty1
PWM2_Set_Duty (current_duty1);
}
Delay_ms (5); // ralentizar el cambio de ritmo un

poco
}
}
Conexión HW
Demostración de PWM
Biblioteca RS-485
RS-485 es una comunicación multipunto que permite conectar múltiples
dispositivos a un solo bus. El mikroC PRO para PIC proporciona un conjunto de
rutinas de biblioteca para un trabajo cómodo con el sistema RS485 utilizando la
arquitectura Maestro / Esclavo. Los dispositivos maestro y esclavo intercambian
paquetes de información. Cada uno de estos paquetes contiene bytes de
sincronización, byte CRC, byte de dirección y los datos. Cada esclavo tiene una
dirección única y recibe solo los paquetes dirigidos a ella. El esclavo nunca puede
iniciar la comunicación.
Es responsabilidad del usuario asegurarse de que solo un dispositivo transmita a
través del bus 485 a la vez.
Las rutinas RS-485 requieren el módulo UART . Los pines de UART deben estar
conectados a un transceptor de interfaz RS-485, como LTC485 o similar (vea el
esquema en la parte inferior de esta página).
Constantes de la biblioteca:
 START valor de byte = 150
 DETENER el valor del byte = 169
 Dirección 50es la dirección de transmisión para todos los esclavos (los
paquetes que contienen la dirección 50serán recibidos por todos los
esclavos, excepto los esclavos con direcciones 150y 169).
Importante:
 La biblioteca utiliza el módulo UART para la comunicación. El usuario
debe inicializar el módulo UART apropiado antes de usar la biblioteca
RS-485.
 Para MCU con múltiples módulos UART es posible inicializarlos y luego
cambiarlos usando la rutina UART_Set_Active .
Dependencias externas de la biblioteca RS-485

La siguiente variable
debe definirse en todos
Descripci
los proyectos Ejemplo:
ón:
utilizando la biblioteca
RS-485:
Controle el
modo de
operación
extern sfr de sbit RS485_rxtx_pin atRC2_bit;
sbitRS485_rxtx_pin; transmisió
n/
recepción
RS-485
Dirección
del pin de
extern sfr
sbitRS485_rxtx_pin_dire transmisió sbitRS485_rxtx_pin_direction at TR
ction; n/ ISC2_bit;
recepción
RS-485
 RS485Master_Init
 RS485Master_Receive
 RS485Master_Send
 RS485Slave_Init
 RS485Slave_Receive
 RS485Slave_Send
RS485Master_Init
Prototipo void RS485Master_Init ();
Devoluciones Nada.
Descripción Inicializa MCU como maestro para la comunicación RS-485.

 RS485_rxtx_pin- este pin está conectado a la
entrada RE / DE del transceptor RS-485 (vea el
esquema en la parte inferior de esta
página). La señal RE / DE controla el modo de
operación del transceptor RS-485.
 RS485_rxtx_pin_direction - Dirección del pin
de transmisión / recepción RS-485.
El módulo UART HW necesita ser

inicializado. Ver UARTx_Init .
Ejemplo // RS485 módulo pinout
sbit RS485_rxtx_pin en RC2_bit; // control de
transmisión / recepción establecido en PORTC.B2
// Pin direction
sbit RS485_rxtx_pin_direction en TRISC2_bit; //
RxTx pin dirección establecida como salida
...
UART1_Init (9600); //
inicializar el módulo
UART1 RS485Master_Init ();
// intialize MCU como maestro para la comunicación
RS-485
RS485Master_Receive
Prototipo void RS485Master_Receive ( char * data_buffer);
Devoluciones Nada.
Descripción Recibe mensajes de esclavos. Los mensajes son de varios

bytes, por lo que esta rutina debe llamarse para cada byte
recibido.
Parámetros:
 data_buffer: Búfer de 7 bytes para almacenar
los datos recibidos, de la siguiente manera:
 data[0..2]: contenido del mensaje

 data_buffer[3]: número de bytes de mensaje
recibidos, 1–3
 data_buffer[4]: se establece en 255 cuando
se recibe el mensaje
 data_buffer[5]: se establece en 255 si se ha
producido un error
 data_buffer[6]: Dirección del esclavo que
envió el mensaje.
La función se ajusta automáticamente data[4]y data[5]en
cada mensaje recibido. Estas banderas deben ser borradas
por el software.
Requiere MCU debe inicializarse como maestro para la comunicación

RS-485. Ver RS485Master_Init .
Ejemplo char msg [8];

...
RS485Master_Receive (msg);
RS485Master_Send
Prototipo void RS485Master_Send ( char *
data_buffer, char datalen, charSlave_address);
Devoluciones Nada.
Descripción Envía mensaje a esclavo (s). El formato del mensaje se

puede encontrar en la parte inferior de esta página.
Parámetros:
 data_buffer: datos a enviar
 datalen:Número de bytes para la
transmisión. Valores válidos: 0 ... 3.
 Slave_address: Dirección de esclavo (s)
Requiere MCU debe inicializarse como maestro para la comunicación

RS-485. Ver RS485Master_Init .
Es responsabilidad del usuario garantizar (por protocolo)
que solo un dispositivo envíe datos a través del bus 485 a
la vez.

...
// envía 3 bytes de datos al esclavo con la
dirección 0x12
RS485Master_Send (msg, 3, 0x12);
RS485Slave_Init
Prototipo void RS485Slave_Init ( char Slave_address);
Devoluciones Nada.
Descripción Inicializa MCU como esclavo para la comunicación RS-485.

Parámetros:
 Slave_address: Dirección de esclavo

 RS485_rxtx_pin- este pin está conectado a la
entrada RE / DE del transceptor RS-485 (vea el
esquema en la parte inferior de esta
página). La señal RE / DE controla el modo de
operación del transceptor RS-485. Valores
válidos: 1(para transmitir) y 0(para recibir
 RS485_rxtx_pin_direction - Dirección del pin
de transmisión / recepción RS-485.
El módulo UART HW necesita ser

inicializado. Ver UARTx_Init .
Ejemplo Inicialice MCU como esclavo con la dirección 160:

// RS485 módulo pinout
sbit RS485_rxtx_pin en RC2_bit; // control de
transmisión / recepción establecido en PORTC.B2
// Pin direction
sbit RS485_rxtx_pin_direction en TRISC2_bit; //
RxTx pin dirección establecida como salida
...
UART1_Init (9600); // inicializar
el módulo
UART1 RS485Slave_Init (160); //
intialize MCU como esclavo para la comunicación RS-
485 con la dirección 160
RS485Slave_Receive
Prototipo void RS485Slave_Receive ( char * data_buffer);
Devoluciones Nada.
Descripción Recibe mensajes del maestro. Si la dirección del esclavo y

el campo de dirección del mensaje no coinciden, el
mensaje se descartará. Los mensajes son de varios bytes,
por lo que esta rutina debe llamarse para cada byte
recibido.
Parámetros:
 data_buffer: Búfer de 6 bytes para almacenar
los datos recibidos, de la siguiente manera:
 data[0..2]: contenido del mensaje

 data[3]: número de bytes de mensaje
recibidos, 1–3
 data[4]: se establece en 255 cuando se recibe
el mensaje
 data[5]: se establece en 255 si se ha
producido un error
La función se ajusta automáticamente data[4]y data[5]en
cada mensaje recibido. Estas banderas deben ser borradas
por el software.
Requiere MCU debe inicializarse como esclavo para la comunicación

RS-485. Ver RS485Slave_Init .

...
RS485Slave_Read (msg);
RS485Slave_Send
Prototipo void RS485Slave_Send ( char *
data_buffer, char datalen);
Devoluciones Nada.
Descripción Envía mensaje a Master. El formato del mensaje se puede

encontrar en la parte inferior de esta página.
Parámetros:
 data_buffer: datos a enviar
 datalen:Número de bytes para la
transmisión. Valores válidos: 0 ... 3.
Requiere MCU debe inicializarse como esclavo para la comunicación

RS-485. Ver RS485Slave_Init . Es responsabilidad del
usuario garantizar (por protocolo) que solo un dispositivo
envíe datos a través del bus 485 a la vez.

...
// envía 2 bytes de datos al maestro
RS485Slave_Send (msg, 2);
Esta es una demostración simple del uso de las rutinas de la biblioteca RS485.
El maestro envía un mensaje al esclavo con la dirección 160 y espera una
respuesta. El esclavo acepta datos, los incrementa y los envía de vuelta al
maestro. Luego, el Maestro hace lo mismo y envía los datos incrementados de
vuelta al Esclavo, etc.
El maestro muestra los datos recibidos en el PORTB, mientras que el error en la
recepción (0xAA) y el número de reintentos consecutivos sin éxito se muestran en
el PORTD. El esclavo muestra los datos recibidos en PORTB, mientras que el error
en la recepción (0xAA) se muestra en PORTD. Las configuraciones de hardware en
este ejemplo están hechas para la placa EasyPIC6 y 16F887.
Código maestro RS485:
char dat [10]; // buffer para recibir / enviar

mensajes
char i, j;
sbit rs485_rxtx_pin en RC2_bit; // establezca el pin de

transconexión sbit rs485_rxtx_pin_direction en TRISC2_bit; //
establecer la dirección del pasador de transcieve
// Interrumpir la rutina
void interrupt () {
RS485Master_Receive (dat);
}
void main () {
long cnt = 0;

digital
ANSELH = 0;
C2ON_bit = 0;
PORTB = 0;
PORTD = 0;
TRISB = 0;
TRISD = 0;
UART1_Init (9600); // inicializar el módulo UART1

Delay_ms (100);
RS485Master_Init (); // inicializar MCU como maestro

dat [0] = 0xAA;
dat [1] = 0xF0;
dat [2] = 0x0F;
dat [4] = 0; // asegúrese de que el indicador
de mensaje recibido sea 0
dat [5] = 0; // Asegúrate de que el indicador
de error sea 0
dat [6] = 0;
RS485Master_Send (dat, 1,160);
RCIE_bit = 1; // habilitar la interrupción en

UART1 recibir
TXIE_bit = 0; // deshabilitar la interrupción en
UART1 transmitir
PEIE_bit = 1; // habilitar interrupciones
periféricas
GIE_bit = 1; // habilitar todas las
interrupciones
while (1) {
// al recibir un mensaje válido
completado
// los datos [4] están configurados
en 255
cnt ++;
if (dat [5]) { // si se detecta un error,
señalícelo PORTD = 0xAA; // estableciendo portd
en 0xAA
}
if (dat [4]) { // si el mensaje se recibió
correctamente
cnt = 0;
dat [4] = 0; // Borrar mensaje recibido
j = dat [3];
para (i = 1; i <= dat [3]; i ++) { // mostrar datos en PORTB
PORTB = dat [i-1];
} // incremento recibido dat [0]
dat [0] = dat [0] +1; // enviar de vuelta al maestro
Delay_ms (1);
}
if (cnt> 100000) {
PORTD ++;
cnt = 0;
if (PORTD> 10) // si el envío falló 10 veces
RS485Master_Send (dat, 1,50); // enviar mensaje en la dirección
de transmisión
}
}
Código esclavo RS485:

charla dat [9]; // buffer para recibir / enviar mensajes

char i, j;
sbit rs485_rxtx_pin en RC2_bit; // establezca el pin de

transconexión sbit rs485_rxtx_pin_direction en TRISC2_bit; //
establecer la dirección del pasador de transcieve
// Interrumpir la rutina
void interrupt () {
RS485Slave_Receive (dat);
}
void main () {
digital
ANSELH = 0;
C2ON_bit = 0;
PORTB = 0;
PORTD = 0;
TRISB = 0;
TRISD = 0;

Delay_ms (100);
RS485Slave_Init (160); // Intialize MCU como esclavo,
dirección 160
dat [4] = 0; // asegúrese de que el indicador de

mensaje recibido sea 0
dat [5] = 0; // asegúrese de que el indicador de
mensaje recibido sea 0
dat [6] = 0; // Asegúrate de que el indicador de
error sea 0
RCIE_bit = 1; // habilitar la interrupción en UART1

recibir
TXIE_bit = 0; // deshabilitar la interrupción en
UART1 transmitir
PEIE_bit = 1; // habilitar interrupciones
periféricas
GIE_bit = 1; // habilitar todas las interrupciones
while (1) {
if (dat [5]) { // si se detecta un error,
señalícelo con PORTD = 0xAA; // estableciendo portd
en 0xAA
dat [5] = 0;
}
if (dat [4]) { // al completarse un mensaje
válido, recibir
dat [4] = 0; // data [4] se establece en 0xFF
j = dat [3];
para (i = 1; i <= dat [3]; i ++) {
PORTB = dat [i-1];
}
dat [0] = dat [0] +1; // incremento recibido dat [0]
Delay_ms (1);
RS485Slave_Send (dat, 1); // y enviarlo de vuelta al maestro
}
}
}
Conexión HW
Ejemplo de interfaz MCU PIC16F887 a MCU PIC16F887 a través del bus RS485 con el LTC485
como transceptor RS-485
Formato de mensaje y cálculos CRC
P: ¿Cómo se calcula la suma de comprobación CRC en el lado maestro RS485?
START_BYTE = 0x96; // 10010110

STOP_BYTE = 0xA9; // 10101001
PAQUETE:
--------
START_BYTE 0x96
DIRECCIÓN
DATALEN
[DATA1] // si existe
CRC
STOP_BYTE 0xA9
DATALEN BITS
------------
bit7 = 1 MASTER SENDS
0 ESCLAVO ENVÍA
bit6 = 1 LA DIRECCIÓN FUE XOREDADA con 1, ES IGUAL A START_BYTE o
STOP_BYTE
0 DIRECCION SIN CAMBIO
bit5 = 0 FIJO
bit4 = 1 DATA3 (si existe) fue XORED con 1, fue igual a START_BYTE o
STOP_BYTE
0 DATA3 (si existe) NO CAMBIADO
STOP_BYTE
0 DATA2 (si existe) NO CAMBIADO
STOP_BYTE
0 DATOS1 (si existe) NO CAMBIADO
bit1bit0 = 0 a 3 NÚMERO DE DATOS BYTES ENVIADOS
Generación de CRC:
----------------
crc_send = datalen ^ address;
crc_send ^ = datos [0]; // si existe
crc_send ^ = data [1]; // si existe
crc_send ^ = data [2]; // si existe
crc_send = ~ crc_send;
if ((crc_send == START_BYTE) || (crc_send == STOP_BYTE))
crc_send ++;
NOTA: DATALEN <4..0> no puede tomar los valores START_BYTE <4..0> o

STOP_BYTE <4..0>.
Biblioteca UART
El módulo de hardware UART está disponible con una serie de MCU compatibles con
PIC. La biblioteca mikroC PRO for PIC UART proporciona un trabajo cómodo con el
modo asíncrono (dúplex completo).
Puede comunicarse fácilmente con otros dispositivos a través del protocolo RS-232
(por ejemplo, con una PC, consulte la figura al final del tema - Conexión RS-232
HW). Necesita un PIC MCU con UART integrado por hardware, por ejemplo
16F887. Luego, simplemente use las funciones enumeradas a continuación.
Importante:
 Las rutinas de la biblioteca UART requieren que especifique el módulo

que desea usar. Para seleccionar el módulo UART deseado ,
simplemente cambie la letra x en el prototipo de rutina para un número
del 1 al 2 .
 La conmutación entre los módulos UART en la biblioteca UART se realiza
mediante la función UART_Set_Active (los módulos UART deben
inicializarse previamente).
 El número de módulos UART por MCU difiere de un chip a otro. Por
favor, lea la hoja de datos correspondiente antes de utilizar esta
biblioteca.
 UARTx_Init
 UARTx_Data_Ready
 UARTx_Tx_Idle
 UARTx_Read
 UARTx_Read_Text
 UARTx_Write
 UARTx_Write_Text
 UART_Set_Active
Rutinas genéricas
 UART_Data_Listo
 UART_Tx_Idle
 UART_Leer
 UART_Read_Text
 UART_escribir
 UART_Write_Text
UARTx_Init
Prototipo void UARTx_Init ( const unseded long baud_rate);
Devoluciones Nada.
Descripción Inicializa el módulo UART de hardware deseado con la

velocidad en baudios deseada. Consulte la hoja de datos
del dispositivo para conocer las velocidades en baudios
permitidas para cada específico Fosc. Si especifica la
velocidad en baudios no admitida, el compilador informará
un error.
Requiere Necesitas PIC MCU con hardware UART .

UARTx_Initdebe llamarse antes de usar otras funciones de
la Biblioteca UART .
Parámetros:
 baud_rate: tasa de baudios solicitada
Consulte la hoja de datos del dispositivo para conocer las
velocidades en baudios permitidas para Fosc específico.
Nota: El compilador realiza el cálculo del valor de la

velocidad en baudios de UART, ya que produciría un código
biblioteca.
Ejemplo // Inicialice el hardware UART1 y establezca la

comunicación a 9600 bps
UART1_Init (9600);
UARTx_Data_Ready
Prototipo char UARTx_Data_Ready ();
Devoluciones  1 si los datos están listos para leer

 0 Si no hay datos en el registro de recepción.
Descripción Utilice la función para probar si los datos en el búfer de

recepción están listos para leer.
Requiere El módulo UART HW debe iniciarse y establecerse la

comunicación antes de usar esta
función. Ver UARTx_Init .
Ejemplo // Si los datos están listos,

léalos : if (UART1_Data_Ready () == 1) {
receive = UART1_Read ();
}
UARTx_Tx_Idle
Prototipo char UARTx_Tx_Idle ();
Devoluciones  1 si los datos han sido transmitidos

 0 de otra manera
Descripción Utilice la función para probar si el registro de

desplazamiento de transmisión está vacío o no.

Ejemplo // Si los datos anteriores se han desplazado, envíe

los siguientes datos:
if (UART1_Tx_Idle () == 1) {
UART1_Write (_data);
}
UARTx_Read
Prototipo char UARTx_Read ();
Devoluciones Devuelve el byte recibido.
Descripción La función recibe un byte a través de UART . Use la

función UARTx_Data_Ready para probar si los datos
están listos primero.

}
UARTx_Read_Text
Prototipo void UARTx_Read_Text ( char * Salida, char *
Delimitador, char Intentos);
Devoluciones Nada.
Descripción Lee los caracteres recibidos a través de UART hasta que se

detecta la secuencia delimitador. La secuencia de lectura
se almacena en el parámetro output; La secuencia
delimitadora se almacena en el parámetro delimiter.
Esta es una llamada de bloqueo: se espera la secuencia del
delimitador, de lo contrario, el procedimiento sale (si no se
encuentra el delimitador).
Parámetros:
 Output: texto recibido
 Delimiter: secuencia de caracteres que
identifica el final de una cadena recibida
 Attempts:define el número de caracteres
recibidos en los que Delimiterse espera la
secuencia. Si Attemptsse establece en 255,
esta rutina intentará continuamente detectar
la Delimitersecuencia.

Ejemplo Lea el texto hasta que se reciba la secuencia "OK", y envíe

lo que se ha recibido:
Delay_ms (100);
while (1) {
if (UART1_Data_Ready () == 1) {// si se reciben
datos
UART1_Read_Text (salida, "OK", 10); // lee el
texto hasta que se encuentra 'OK'
UART1_Write_Text (salida); // devuelve el texto
}
}
UARTx_Write
Prototipo void UARTx_Write ( char data_);
Devoluciones Nada.
Descripción La función transmite un byte a través del módulo UART .

Parámetros:
 _data: datos a enviar

Ejemplo unsigned char _data = 0x1E;

...
UARTx_Write_Text
Prototipo void UARTx_Write_Text ( char * UART_text);
Devoluciones Nada.
Descripción Envía texto a través de UART . El texto debe estar

terminado en cero.
Parámetros:
 UART_text: texto a enviar


Delay_ms (100);
while (1) {
datos
}
}
UART_Set_Active
Prototipo void UART_Set_Active ( char (* read_ptr)
(), void (* write_ptr) ( unsigned
char data_), char (* ready_ptr) (), char (*
tx_idle_ptr) ())
Devoluciones Nada.
Descripción Establece el módulo UART activo que será utilizado por
las rutinas de la biblioteca UART .
Parámetros:
 read_ptr: UARTx_Read handler
 write_ptr: UARTx_Write manejador
 ready_ptr: UARTx_Data_Ready handler
 tx_idle_ptr: UARTx_Tx_Idle handler
Requiere La rutina solo está disponible para MCU con

dos módulos UART .
El módulo UART usado debe inicializarse antes de usar esta
rutina. Ver la rutina UARTx_Init.
Ejemplo UART1_Init (9600); // inicializar

el módulo
UART1 UART2_Init (9600); //
inicializar el módulo UART2
RS485Master_Init (); // inicializar

MCU como maestro
UART_Set_Active (& UART1_Read, & UART1_Write, &

UART1_Data_Ready, & UART1_Tx_Idle); // establece
UART1 RS485Master_Send activo
(dat, 1,160); // enviar mensaje a través de
UART1

UART2 activo
RS485Master_Send (dat, 1,160); // enviar a
través de UART2
UART_Data_Listo
Prototipo char UART_Data_Ready ();


Esta es una rutina genérica que utiliza el módulo UART
activo previamente activado por
la rutina UART_Set_Active .

Software I²C Library

El mikroC PRO for PIC proporciona rutinas para implementar la comunicación
de Software I²C . Estas rutinas son independientes del hardware y se pueden
utilizar con cualquier MCU. La biblioteca de software I²C le permite utilizar MCU
como maestro en la comunicación I²C . El modo multi-master no es compatible.
Importante:
 Esta biblioteca implementa actividades basadas en el tiempo, por lo que

las interrupciones deben desactivarse cuando se utiliza Software I²C .
 Todas las funciones de la biblioteca I²C son funciones de llamada de
bloqueo (están esperando que la línea del reloj I²C se convierta en una
lógica).
 Los pines utilizados para la comunicación del software I²C deben estar
conectados a las resistencias de pull-up. También puede ser necesario
apagar los LED conectados a estos pines.
 Cada rutina de la biblioteca I²C del software tiene su propia
contrapartida en la biblioteca I²C del hardware ,
excepto I2C_Repeated_Start. Soft_I2C_Startse utiliza en lugar
de I2C_Repeated_Start.
 La frecuencia de reloj de trabajo del Software I²C es 20kHz.
Dependencias externas de la biblioteca de software I²C
Las siguientes
variables deben
definirse en todos los Descripció
Ejemplo:
proyectos que utilicen n:
la Biblioteca I²C de
Software:
Línea de
extern
sbitSoft_I2C_Scl; reloj suave sbit Soft_I2C_Scl atRC3_bit;
I²C.
Línea de
extern
sbitSoft_I2C_Sda; datos de sbit Soft_I2C_Sda atRC4_bit;
I²C suave.
extern Dirección
sbitSoft_I2C_Scl_Direction at TRIS
sbitSoft_I2C_Scl_Direc del reloj C3_bit;
tion; Soft I²C.
Dirección
extern
sbitSoft_I2C_Sda_Direc
del pin de sbitSoft_I2C_Sda_Direction at TRIS
tion; datos Soft C4_bit;
I²C.
 Soft_I2C_Init
 Soft_I2C_Start
 Soft_I2C_Leer
 Soft_I2C_Write
 Soft_I2C_Stop
 Soft_I2C_Break
Soft_I2C_Init
Prototipo void Soft_I2C_Init ();
Devoluciones Nada.
Descripción Configura el módulo I²C del software .
 Soft_I2C_Scl: Soft I²C línea de reloj

 Soft_I2C_Sda: Línea de datos I²C suave
 Soft_I2C_Scl_Pin_Direction: Dirección del pin
de reloj Soft I²C
 Soft_I2C_Sda_Pin_Direction: Dirección del pin
de datos Soft I²C
Ejemplo // Conexiones de software I2C

sbit Soft_I2C_Scl en RC3_bit;
sbit Soft_I2C_Sda en RC4_bit;
sbit Soft_I2C_Scl_Direction en TRISC3_bit;
sbit Soft_I2C_Sda_Direction at TRISC4_bit;
// Terminar las conexiones I2C del software
...
Soft_I2C_Init ();
Soft_I2C_Start
Prototipo void Soft_I2C_Start ( void );
Devoluciones Nada.
Descripción Determina si el bus I²C está libre y emite la señal de

INICIO.
Requiere El software I²C debe configurarse antes de usar esta

función. Ver la rutina Soft_I2C_Init .
Ejemplo // Emite la señal de INICIO

Soft_I2C_Start ();
Soft_I2C_Leer
Prototipo breve sin firmar Soft_I2C_Read ( unsigned
int ack);
Devoluciones Un byte del esclavo.
Descripción Lee un byte del esclavo.

Parámetros:
 ack:reconocer el parámetro de señal. Si
la señal de ack==0 no confirmación se enviará
después de la lectura, de lo contrario se
enviará la señal de confirmación .
Requiere Soft I²C debe configurarse antes de usar esta función. Ver
la rutina Soft_I2C_Init .
utilizar esta función. Ver la rutina Soft_I2C_Start .
Ejemplo toma corta sin firmar ;

...
// Lea los datos y envíe la señal de not_acknowledge
toma = Soft_I2C_Read (0);
Soft_I2C_Write
Prototipo Soft_I2C_Write corto sin firmar (datos cortos
sin firmar);
Devoluciones  0 Si no hubiera errores.

 1Si se detectó una colisión de escritura en
el bus I²C .
Descripción Envía el byte de datos a través del bus I²C .

Parámetros:
 data_: datos a enviar
utilizar esta función. Ver la rutina Soft_I2C_Start .
Ejemplo datos cortos sin firmar, error;

...
error = Soft_I2C_Write (data_);
error = Soft_I2C_Write (0xA3);
Soft_I2C_Stop
Prototipo void Soft_I2C_Stop ( void );
Devoluciones Nada.
Descripción Emite la señal de parada.
Ejemplo // Emisión de la señal de PARO

Soft_I2C_Stop ();
Soft_I2C_Break
Prototipo void Soft_I2C_Break ( void );
Devoluciones Nada.
Descripción Todas las funciones de la Biblioteca I²C

de Software pueden bloquear el flujo del programa (vea la
nota en la parte superior de esta página). Llamar a esta
rutina desde la interrupción desbloqueará la ejecución del
Nota: Las interrupciones se deben desactivar antes

de usar las rutinas de Software I²C nuevamente (vea la
nota al principio de esta página).
Requiere Nada.
Ejemplo
// Conexiones de software I2C
contador de char = 0;
interrupción del vacío {
if (INTCON.T0IF) {
Soft_I2C_Break ();
contador
}
else
incrementos

}
}
void main () {

ajustado a 1:32
...
// prueba Soft_I2C_Init con el mecanismo de

Soft_I2C_Init ();
...
}
El ejemplo demuestra el uso de las rutinas de la biblioteca I²C del software . El
PIC MCU está conectado (pines SCL, SDA) al PCF8583 RTC (reloj en tiempo
real). La fecha y la hora del programa se leen desde el RTC y se imprimen en Lcd.
// Conexiones de software I2C



char segundos, minutos, horas, día, mes, año; // Variables de fecha / hora
globales
// --------------------- Lee información de fecha y hora de RTC (PCF8583)

void Read_Time () {
Soft_I2C_Start (); // Emisión de la señal de inicio

Soft_I2C_Write (0xA0); // Dirección PCF8583, consulte la hoja
de datos de
PCF8583 Soft_I2C_Write (2); // Comenzar desde la dirección
2
Soft_I2C_Start (); // Emite una señal de inicio repetida
Soft_I2C_Write (0xA1); // Dirección PCF8583 para leer R / W =
1
segundos = Soft_I2C_Read (1); // Leer segundos, byte

minutos = Soft_I2C_Read (1); // Lectura de minutos en minutos
= Soft_I2C_Read (1); // Leer horas byte
day = Soft_I2C_Read (1); // Leer año / día
mes mes = Soft_I2C_Read (0); // Leer el día de la semana / mes
byte
Soft_I2C_Stop (); // emitir señal de parada
// -------------------- Formatos de fecha y hora

void Transform_Time () {
segundos = ((segundos y 0xF0) >> 4) * 10 + (segundos y 0x0F); //
Transformar segundos
minutos = ((minutos & 0xF0) >> 4) * 10 + (minutos & 0x0F); //
Transformar meses
horas = ((horas & 0xF0) >> 4) * 10 + (horas & 0x0F); // Transformar
horas
año = (día & 0xC0) >> 6; // Transformar
día día = ((día & 0x30) >> 4) * 10 + (día & 0x0F); // Transformar
día
mes = ((mes & 0x10) >> 4) * 10 + (mes & 0x0F); // transformar mes
}
// -------------------- Salida de valores a LCD

void Display_Time () {
Lcd_Chr (1, 6, (día / 10) + 48); // Imprimir decenas de dígitos de

la variable del día
Lcd_Chr (1, 7, (día% 10) + 48); // Imprimir un dígito del día
variable
Lcd_Chr (1, 9, (mes / 10) + 48);
Lcd_Chr (1,10, (mes% 10) + 48);
Lcd_Chr (1,15, año + 48); // Imprimir año variable (inicio del año
2010)
Lcd_Chr (2, 6, (horas / 10) + 48);

Lcd_Chr (2, 7, (horas% 10) + 48);
Lcd_Chr (2, 9, (minutos / 10) + 48);
Lcd_Chr (2,10, (minutos% 10) + 48);
Lcd_Chr (2,12, (segundos / 10) + 48);
Lcd_Chr (2,13, (segundos% 10) + 48);
}
// ------------------ Ejecuta todo el proyecto

void Init_Main () {
TRISB = 0;
PORTB = 0xFF;
TRISB = 0xff;
ANSEL = 0; // Configurar pines AN como E / S digital
ANSELH = 0;
C2ON_bit = 0;
Soft_I2C_Init (); // Inicializar la comunicación Soft I2C

Lcd_Cmd (_LCD_CLEAR); // Pantalla LCD clara
Lcd_Cmd (_LCD_CURSOR_OFF); // apagar el cursor
Lcd_Out (1,1, "Fecha:"); // Preparar y generar texto estático en

LCD
Lcd_Chr (1,8, '.');
Lcd_Chr (1,11, '.');
Lcd_Chr (1,16, '.');
Lcd_Out (2,1, "Time:");
Lcd_Chr (2,8, ':');
Lcd_Chr (2,11, ':');
Lcd_Out (1,12, "201"); // inicio del año 2010
}
// ----------------- Main procedimiento

void main () {
Delay_ms (500);
Init_Main (); // Realizar la inicialización

Read_Time (); // Tiempo de lectura de RTC (PCF8583)
Transform_Time (); // Formato de fecha y hora
Display_Time (); // Preparar y mostrar en LCD
}
}
Software SPI Library

El mikroC PRO para PIC proporciona rutinas para implementar la comunicación
de software SPI . Estas rutinas son independientes del hardware y se pueden
utilizar con cualquier MCU. El software SPI Library proporciona una comunicación
fácil con otros dispositivos a través de SPI : convertidores A / D, convertidores D /
A, MAX7219, LTC1290, etc.
Configuración de la biblioteca:
 SPI al modo maestro

 Valor del reloj = 20 kHz.
 Datos muestreados en el medio del intervalo.
 Reloj en estado inactivo bajo.
 Datos muestreados en el medio del intervalo.
 Datos transmitidos de menor a mayor borde.
La biblioteca configura SPI en el modo maestro, reloj = 20kHz, datos muestreados
en el medio del intervalo, estado de inactividad del reloj bajo y datos transmitidos
de borde bajo a alto.
Importante: La biblioteca de software SPI implementa actividades basadas

en el tiempo, por lo que las interrupciones deben desactivarse al usarlas.
Dependencias externas de la biblioteca de software SPI

Las siguientes
variables deben
definirse en todos los Descripció
Ejemplo:
proyectos usando la n:
biblioteca de software
SPI:
extern sfr Datos en

sbit SoftSpi_SDI atRC4_bit;
sbitSoftSpi_SDI; línea.
Línea de
extern sfr
sbitSoftSpi_SDO; salida de sbit SoftSpi_SDO atRC5_bit;
datos.

sbit SoftSpi_CLK atRC3_bit;
sbitSoftSpi_CLK; reloj
extern sfr
sbitSoftSpi_SDI_Direction at TRISC
sbitSoftSpi_SDI_Direct Dirección
4_bit;
ion; de los
datos en el
pin.

sbitSoftSpi_SDO_Direction at TRISC
sbitSoftSpi_SDO_Direct del pin 5_bit;
ion; Data Out

sbitSoftSpi_CLK_Direction at TRISC
sbitSoftSpi_CLK_Direct del pin del 3_bit;
ion; reloj.
 Soft_SPI_Init
 Soft_SPI_Leer
 Soft_SPI_Write
Soft_SPI_Init
Prototipo void Soft_SPI_Init ();
Devoluciones Nada.
Descripción Configura e inicializa el módulo de software SPI .
Requiere Variables globales:

 SoftSpi_SDI: Datos en linea
 SoftSpi_SDO: Línea de datos
 SoftSpi_CLK: Línea de reloj de datos
 SoftSpi_SDI_Direction: Dirección de los datos
en el pin.
 SoftSpi_SDO_Direction: Dirección del pin de
salida de datos
 SoftSpi_CLK_Direction: Dirección del pin del
reloj de datos
Ejemplo // Conexiones del módulo de software SPI

sbit SoftSpi_SDI en RC4_bit;
sbit SoftSpi_SDO en RC5_bit;
sbit SoftSpi_CLK en RC3_bit;
sbit SoftSpi_SDI_Direction en TRISC4_bit;

sbit SoftSpi_SDO_Direction en TRISC5_bit;
sbit SoftSpi_CLK_Direction en TRISC3_bit;
// Terminar las conexiones del módulo SPI del
software
...
Soft_SPI_Init (); // Init Soft_SPI
Soft_SPI_Leer
Prototipo sin signo Soft_SPI_Read ( char sdata);
Devoluciones Byte recibido a través del bus SPI.
Descripción Esta rutina realiza 3 operaciones

simultáneamente. Proporciona reloj para el bus SPI del
software , lee un byte y envía un byte.
Parámetros:
 sdata: Datos a enviar.
Requiere El SPI suave debe inicializarse antes de usar esta

función. Ver la rutina Soft_SPI_Init .
Ejemplo breve data_read sin firmar;

char data_send;
...
// Leer un byte y asignarlo a la variable data_read
// (el byte data_send se enviará a través de SPI
durante la operación de lectura)
data_read = Soft_SPI_Read (data_send);
Soft_SPI_Write
Prototipo void Soft_SPI_Write ( char sdata);
Devoluciones Nada.
Descripción Esta rutina envía un byte a través del bus Software SPI .
Parámetros:
 sdata: Datos a enviar.
Requiere El SPI suave debe inicializarse antes de usar esta

función. Ver la rutina Soft_SPI_Init .
Ejemplo // Escribir un byte en el bus Soft SPI

Soft_SPI_Write (0xAA);
Este código demuestra el uso de rutinas de biblioteca para la comunicación
Soft_SPI. Además, este ejemplo demuestra cómo trabajar con el convertidor D / A
de 12 bits MCP4921 de Microchip.
// Conexiones del módulo DAC

sbit Chip_Select at RC0_bit;
sbit SoftSpi_CLK en RC3_bit;
sbit SoftSpi_SDI en RC4_bit;
sbit SoftSpi_SDO en RC5_bit;
sbit Chip_Select_Direction en TRISC0_bit;
sbit SoftSpi_CLK_Direction en TRISC3_bit;
sbit SoftSpi_SDI_Direction en TRISC4_bit;
sbit SoftSpi_SDO_Direction en TRISC5_bit;
// Terminar las conexiones del módulo DAC
valor int sin firmar ;
void InitMain () {
TRISA0_bit = 1; // Establecer el pin RA0 como
entrada
entrada
Chip_Select = 1; // Deselecciona DAC
Chip_Select_Direction = 0; // Establecer el pin CS # como
salida
Soft_SPI_Init (); // Inicializar Soft_SPI
}
// incrementos del CAD (0..4095) -> tensión de salida (0..Vref)

void DAC_Output ( unsigned int valueDAC) {
Char temp;
Chip_Select = 0; // Seleccionar chip DAC
// Enviar alto byte

temp = (valueDAC >> 8) & 0x0F; // Almacene valueDAC [11..8] a
temp [3..0]
temp | = 0x30; // Definir la configuración de
DAC, ver la hoja de datos de
MCP4921 Soft_SPI_Write (temp); // Enviar alto byte a
través de Soft SPI
// Enviar Low Byte

temp = valueDAC; // Almacenar valueDAC [7..0] a
temp [7..0]
Soft_SPI_Write (temp); // Enviar byte bajo a través de
Soft SPI
Chip_Select = 1; // Deseleccionar chip DAC

}
void main () {
ANSEL = 0; // Configurar AN pins como

digitales
ANSELH = 0;
C2ON_bit = 0;
InitMain (); // Realizar la inicialización

principal
valor = 2048; // Cuando se inicia el programa,

DAC da
// la salida en el rango medio
if ((RA0_bit) && (valor <4095)) { // Si se presiona el botón RA0

value ++; // valor de incremento
}
else {
if ((RA1_bit) && (valor> 0)) { // Si se presiona el botón RA1
value--; // valor decremento
}
}
DAC_Output (valor); // Enviar valor al chip DAC

Delay_ms (1); // Ralentizar el ritmo de
repetición de tecla
}
}
Software UART Library

El mikroC PRO for PIC proporciona rutinas para implementar la comunicación UART
del software . Estas rutinas son independientes del hardware y se pueden utilizar
con cualquier MCU.
El software UART Library proporciona una comunicación fácil con otros dispositivos
a través del protocolo RS232.
Importante: la biblioteca de software UART implementa actividades

basadas en el tiempo, por lo que las interrupciones deben deshabilitarse al
usarlas.
 Soft_UART_Init
 Soft_UART_Leer
 Soft_UART_escribir
 Soft_UART_Break
Soft_UART_Init
Prototipo char Soft_UART_Init ( char *
port, char rx_pin, char tx_pin, long
firmadabaud_rate, char invertida);
Devoluciones  2 - error, la velocidad en baudios solicitada es

demasiado baja
 1 - Error, la velocidad de transmisión solicitada
es demasiado alta.
 0 - inicialización exitosa
Descripción Configura e inicializa el módulo de software UART .

Parámetros:
 port: puerto a utilizar.
 rx_pin: establece rx_pin para ser utilizado.
 tx_pin: establece tx_pin para ser utilizado.
 baud_rate:velocidad de transmisión a
establecer. La velocidad de transmisión
máxima depende del reloj y las condiciones de
trabajo de la MCU.
 inverted:bandera de salida invertida. Cuando
se establece en un valor distinto de cero, se
utiliza la lógica invertida en la salida.
Las rutinas de software de UART usan
la rutina Delay_Cyc . Si la velocidad en baudios solicitada
es demasiado baja, el parámetro calculado para la
llamada Delay_Cycexcede el Delay_Cycrango del
argumento.
Si la velocidad en baudios solicitada es demasiado alta, el
error de redondeo del Delay_Cycargumento corrompe
los tiempos de UART del software .
Requiere Nada.
Ejemplo Esto inicializará el software UART y establecerá la

comunicación a 14400 bps :
error de char ;
...
error = Soft_UART_Init (& PORTC, 7, 6, 14400, 0); //
Inicializar Soft UART a 14400 bps
Soft_UART_Leer
Prototipo char Soft_UART_Read ( char * error);
Devoluciones Byte recibido a través de UART.
Descripción La función recibe un byte a través del software UART .

Esta es una llamada a la función de bloqueo (espera el bit
de inicio). El programador puede desbloquearlo llamando a
la rutina Soft_UART_Break .
Parámetros:
 error: Bandera de error El código de error se
devuelve a través de esta variable.
 0 - No hay error
 1 - Detener error de bit
 255- abortar
usuario, llamado Soft_UART_Break
Requiere El software UART debe inicializarse antes de usar esta

función. Ver la rutina Soft_UART_Init .
Ejemplo char data_, error;

...
// esperar hasta que se reciban los datos
hacer
data = Soft_UART_Read (& error);
mientras (error);
// Ahora podemos trabajar con datos:

if (data_) {...}
Soft_UART_escribir
Prototipo void Soft_UART_Write ( char udata);
Devoluciones Nada.
Descripción Esta rutina envía un byte a través del bus
de software UART .
Parámetros:
 udata: Datos a enviar.
Requiere El software UART debe inicializarse antes de usar esta

función. Ver la rutina Soft_UART_Init .
Tenga en cuenta que durante la transmisión, el
software UART no puede recibir datos; el protocolo de
transferencia de datos debe configurarse de tal forma que
se evite la pérdida de información.
Ejemplo char some_byte = 0x0A;

...
// Escribir un byte a través de Soft UART
Soft_UART_Write (some_byte);
Soft_UART_Break
Prototipo void Soft_UART_Break ();
Devoluciones Nada.
Descripción Soft_UART_Read está bloqueando la rutina y puede

bloquear el flujo del programa. Llamar a esta rutina desde
la interrupción desbloqueará la ejecución del
Nota: Las interrupciones se deben desactivar antes

de usar las rutinas de Software UART nuevamente (vea la
nota al principio de esta página).
Requiere Nada.
Ejemplo char data1, error, contador = 0;
interrupción del vacío () {
if (INTCON.T0IF) {
Soft_UART_Break ();
contador
}
else
incrementos

}
}
void main () {
ajustado a 1:32
...
if (Soft_UART_Init (& PORTC, 7, 6, 9600, 0) == 0)

Soft_UART_Write (0x55);
...
// prueba Soft_UART_Read con el mecanismo de

data1 = Soft_UART_Read (& error);
Este ejemplo demuestra el intercambio de datos simple a través del
software UART . Si MCU está conectada a la PC, puede probar el ejemplo desde
la herramienta de terminal mikroC PRO for PIC USART .
char i, error, byte_read; // variables auxiliares
void main () {

digital
ANSELH = 0;
TRISB = 0x00; // Establecer PORTB como salida

(señalización de error)
PORTB = 0; // No hay error
error = Soft_UART_Init (& PORTC, 7, 6, 14400, 0); // Inicializar Soft

UART a 14400 bps
si (error> 0) {
PORTB = error; // Señalizar error inicial
mientras que (1); // Detener programa
}
Delay_ms (100);
para (i = 'z'; i> = 'A'; i--) { // Enviar bytes desde 'z'

hasta 'A'
Soft_UART_Write (i);
Delay_ms (100);
}

byte_read = Soft_UART_Read (& error); // Leer byte, luego probar el
indicador de error
si (error) // Si se detectó
un error PORTB = error; // señalizarlo en PORTB
else
Soft_UART_Write (byte_read); // Si el error no fue
detectado, devuelve el byte leído
}
}
Biblioteca de sonidos
El mikroC PRO para PIC proporciona una biblioteca de sonidos para proporcionar a
los usuarios las rutinas necesarias para la señalización de sonido en sus
aplicaciones. La generación de sonido necesita hardware adicional, como un altavoz
piezoeléctrico (el ejemplo de la interfaz de un altavoz piezoeléctrico se encuentra
en el esquema al final de esta página).
 Sound_Init
 Sonido_jugar
Sound_Init
Prototipo void Sound_Init ( char * snd_port, char snd_pin);
Devoluciones Nada.
Descripción Configura el pin MCU apropiado para la generación de

sonido.
Parámetros:
 snd_port: dirección del puerto de salida de
sonido
 snd_pin: pin de salida de sonido
Requiere Nada.
Ejemplo // Inicialice el pin RC3 para reproducir sonido

Sound_Init (& PORTC, 3);
Sonido_jugar
Prototipo void Sound_Play
( unsigned freq_in_hz, unsigned duration_ms);
Devoluciones Nada.
Descripción Genera la señal de onda cuadrada en el pin apropiado.

Parámetros:
 freq_in_hz: frecuencia de señal en Hertz (Hz)
 duration_ms: duración de la señal en
milisegundos (ms)
Nota: El rango de frecuencia está limitado por

el parámetro Delay_Cyc . La frecuencia máxima que
puede ser producida por esta función es Freq_max =
Fosc/(80*3). La frecuencia mínima es Freq_min =
Fosc/(80*255). La frecuencia generada puede diferir
del freq_in_hzparámetro debido a la aritmética de enteros.
Requiere Para escuchar el sonido, necesita un altavoz piezoeléctrico

(u otro hardware) en el puerto designado. Además, debe
llamar a Sound_Init para preparar el hardware para la
salida antes de usar esta función.
Ejemplo // Reproducir sonido de 1KHz en 100ms de duración.

Reproducción de sonido (1000, 100);
El ejemplo es una simple demostración de cómo usar la biblioteca de sonidos para
reproducir tonos en un altavoz piezoeléctrico.
void Tone1 () {
Juego de sonido (659, 250); // Frecuencia = 659Hz, duración = 250ms
}
void Tone2 () {
Juego de sonido (698, 250); // Frecuencia = 698Hz, duración = 250ms
}
void Tone3 () {
Sound_Play (784, 250); // Frecuencia = 784Hz, duración = 250ms
}
void Melody () { // Toca la melodía "Casa amarilla"

Tone1 (); Tone2 (); Tone3 (); Tone3 ();
Tone1 (); Tone2 (); Tone3 ();
Tone1 (); Tone2 (); Tone3 ();
Tone3 (); Tone3 (); Tone2 (); Tone2 (); Tone1 ();
}
void ToneA () {
Juego de sonido (880, 50);
}
void ToneC () {
}
tono vacío () {
}
void Melody2 () {
sin signo i corto ;
para (i = 9; i> 0; i--) {
ToneA (); ToneC (); ToneE ();
}
}
void main () {

ANSELH = 0;
C2ON_bit = 0;
TRISB = 0xF8; // Configurar RB7..RB3 como entrada
Sound_Init (& PORTC, 3);

Reproducción de sonido (880, 1000); // Reproducir sonido a
880Hz por 1 segundo
while (1) {
if (Button (& PORTB, 7,1,1)) // RB7 reproduce Tone1
Tone1 ();
while (RB7_bit); // Espera a que se suelte el botón

Tone2 ();

Tone3 ();
if (Button (& PORTB, 4,1,1)) // RB4 reproduce Melody2

Melody2 ();
if (Button (& PORTB, 3,1,1)) // RB3 reproduce Melody

Melodía();
}
}
Conexión HW
Ejemplo de conexión a la biblioteca de sonidos
Biblioteca SPI
El mikroC PRO para PIC proporciona una biblioteca para que se sienta cómodo con
el trabajo SPI en modo Maestro. El PIC MCU puede comunicarse fácilmente con
otros dispositivos a través de SPI : convertidores A / D, convertidores D / A,
MAX7219, LTC1290, etc.
Importante:
 Las rutinas SPI requieren que especifique el módulo que desea

usar. Para seleccionar el SPI deseado , simplemente cambie la letra xen
el prototipo para un número de 1a 2.
El número de módulos SPI por MCU difiere de un chip a otro. Por favor,
lea la hoja de datos correspondiente antes de utilizar esta biblioteca.
 Algunas MCU tienen múltiples módulos SPI . La conmutación entre
los módulos SPI en la biblioteca SPI se realiza mediante
la función SPI_Set_Active (el módulo SPI debe inicializarse
previamente).
 Algunas de las MCU no admiten la rutina SPIx_Init_Advanced . Por
favor, consulte la hoja de datos correspondiente.
 Ciertas líneas SPI en algunas MCU de familia mejoradas PIC16 se
pueden enrutar a través de pines alternativos. Estos pines se
seleccionan configurando el registro APFCON y el registro TRIS
apropiado.
 SPIx_Init
 SPIx_Init_Advanced
 SPIx_Read
 SPIx_Write
 SPI_Set_Active
Rutinas genéricas
 SPI_Read
 SPI_Write
SPIx_Init
Prototipo void SPIx_Init ();
Devoluciones Nada.
Descripción Esta rutina configura y habilita el módulo SPI con las

siguientes configuraciones:
 modo maestro
 reloj fosc / 4
 reloj en estado inactivo bajo
 datos transmitidos en el borde bajo al alto
 datos de entrada muestreados en el medio del
intervalo
Requiere Necesitas PIC MCU con hardware integrado SPI .
Ejemplo // Inicialice el módulo SPI1 con la configuración

predeterminada
SPI1_Init ();
SPIx_Init_Advanced
Prototipo anular SPIx_Init_Advanced ( unsigned
short master_slav, corto sin
signo data_sample, corto sin
signo clock_idle, unsigned short transmit_edge);
Devolucio Nada.
nes
Descripció Configura e
n inicializa SPI . SPIx_Init o SPIx_Init_Advanced debe llamarse
antes de usar otras funciones de la biblioteca SPI .
Parámetros mode, data_sampley clock_idleconfigure el
módulo SPI, y puede tener los siguientes valores:
Modo de trabajo SPI:
Master clock =
_SPI_MASTER_OSC_DIV4
Fosc/4
Master clock =
Fosc/16
Master clock =
Fosc/64
Master clock
_SPI_MASTER_TMR2
source TMR2
Slave select
_SPI_SLAVE_SS_ENABLE
enabled
Slave select
_SPI_SLAVE_SS_DIS
disabled
Intervalo de muestreo de datos:
Input data sampled

in middle of _SPI_DATA_SAMPLE_MIDDLE
interval
Input data sampled

at the end of _SPI_DATA_SAMPLE_END
interval
SPI reloj estado inactivo:
Clock idle HIGH _SPI_CLK_IDLE_HIGH
Clock idle LOW _SPI_CLK_IDLE_LOW

Borde de transmisión:
Data transmit on
_SPI_LOW_2_HIGH
low to high edge
Data transmit on
_SPI_HIGH_2_LOW
high to low edge
Ejemplo // Establezca el módulo SPI1 en modo maestro, reloj =

Fosc / 4, datos muestreados en el medio del intervalo,
estado de inactividad del reloj bajo y datos
transmitidos de borde bajo a alto:
SPI1_Init_Advanced
(_SPI_MASTER_OSC_DIV_DIV4_LIV_LIV_LAMPAD_PK_DIV_DID_SAM
PLE_MIDDLE, _SPI_CLK_IDK_IDL__SIV_CLK_IDL__DIV4
SPIx_Read
Prototipo SPIx_Read corto sin firmar ( buffer corto sin
firmar );
Devoluciones Devuelve los datos recibidos.
Descripción Lee un byte del bus SPI.

Parámetros:
 buffer: datos ficticios para la generación de
reloj (consulte la hoja de datos del dispositivo
para los detalles de implementación de los
módulos SPI)

SPI debe ser inicializado y la comunicación establecida
antes de usar esta
función. Consulte SPIx_Init_Advanced o SPIx_Init .
Ejemplo toma corta , amortiguador;

...
take = SPI1_Read (buffer);
SPIx_Write
Prototipo void SPIx_Write (datos cortos sin firmar);
Devoluciones Nada.
Descripción Escribe byte a través del bus SPI.

Parámetros:
 wrdata: datos a enviar

antes de usar esta
Ejemplo // escribir un byte en el bus SPI

carbón de amortiguación;
...
SPI1_Write (buffer);
SPI_Set_Active
Prototipo void SPI_Set_Active ( char (* read_ptr)
( char ), void (* write_ptr) ( char ))
Devoluciones Nada.
Descripción Establece el módulo SPI activo que será utilizado por

las rutinas SPI .
Parámetros:
 read_ptr: SPIx_Read handler
 write_ptr: SPIx_Write manejador
Requiere La rutina está disponible solo para MCU con dos módulos
SPI.
El módulo SPI usado debe inicializarse antes de usar esta
función. Ver el SPIx_Init , SPIx_Init_Advanced
Ejemplo SPI_Set_Active (& SPI2_Read, & SPI2_Write); //

Establece el módulo SPI2 activo
SPI_Read
Prototipo SPI_Read corto sin firmar ( buffer corto sin
firmar );

Esta es una rutina genérica que utiliza el módulo SPI activo
previamente activado por la rutina SPI_Set_Active .
Parámetros:
 buffer: datos ficticios para la generación de
reloj (consulte la hoja de datos del dispositivo
para los detalles de implementación de los
módulos SPI)

antes de usar esta
...
take = SPI_Read (búfer);
SPI_Write
Prototipo void SPI_Write (datos cortos sin firmar);
Devoluciones Nada.
Descripción Escribe byte a través del bus SPI.

Esta es una rutina genérica que utiliza el módulo SPI activo
previamente activado por la rutina SPI_Set_Active .
Parámetros:
 wrdata: datos a enviar

antes de usar esta
Ejemplo // escribir un byte en el bus SPI

carbón de amortiguación;
...
SPI_Write (buffer);
El código muestra cómo usar las funciones de la biblioteca SPI para la comunicación
entre el módulo SPI de la MCU y el convertidor D / A de 12 bits MCP4921 de
Microchip
// Conexiones del módulo DAC

sbit Chip_Select at RC0_bit;
sbit Chip_Select_Direction en TRISC0_bit;
// Terminar las conexiones del módulo DAC
valor int sin firmar ;
void InitMain () {
entrada
entrada
Chip_Select = 1; // Deselecciona DAC
Chip_Select_Direction = 0; // Establecer el pin CS # como
salida
SPI1_Init (); // Inicializar módulo SPI
}
// incrementos del CAD (0..4095) -> tensión de salida (0..Vref)

void DAC_Output ( unsigned int valueDAC) {
Char temp;
Chip_Select = 0; // Seleccionar chip DAC
// Enviar alto byte

temp = (valueDAC >> 8) & 0x0F; // Almacene valueDAC [11..8] a
temp [3..0]
temp | = 0x30; // Defina la configuración DAC,
consulte la hoja de datos
MCP4921 SPI1_Write (temp); // Enviar alto byte a
través de SPI
// Enviar Low Byte

temp = valueDAC; // Almacene valueDAC [7..0] a
temp [7..0]
SPI1_Write (temp); // Enviar byte bajo a través de
SPI
Chip_Select = 1; // Deseleccionar chip DAC

}
void main () {
ANSEL = 0;
ANSELH = 0;
InitMain (); // Realizar la inicialización
principal
valor = 2048; // Cuando se inicia el programa,

DAC da
// la salida en el rango medio
if ((RA0_bit) && (valor <4095)) { // Si se presiona el botón RA0

value ++; // valor de incremento
}
else {
if ((RA1_bit) && (valor> 0)) { // Si se presiona el botón RA1
value--; // valor decremento
}
}
DAC_Output (valor); // Enviar valor al chip DAC
Delay_ms (1); // Ralentizar el ritmo de
repetición de tecla
}
}
Conexión HW
Conexión SPI HW
Biblioteca extraíble SPI

mikroC PRO para bibliotecas PIC > Bibliotecas de hardware >
Biblioteca extraíble SPI

El módulo SPI Remappable está disponible con estas MCU: 18F2xJ11, 18F4xJ11,
18F2xJ50 y 18F4xJ50. mikroC PRO for PIC proporciona una biblioteca para
inicializar el modo Esclavo y un trabajo cómodo con el modo Maestro. PIC puede
comunicarse fácilmente con otros dispositivos a través de SPI : convertidores A /
D, convertidores D / A, MAX7219, LTC1290, etc.
Nota: Antes de usar esta biblioteca, asegúrese de que la Biblioteca de

selección de pin periférico y la Biblioteca SPI estén marcadas en el Administrador
de bibliotecas , y de que se hayan asignado los pines apropiados.
 SPI_Remappable_Init
 SPI_Remappable_Init_Advanced
 SPI_Remappable_Read
 SPI_Remappable_Write
SPI_Remappable_Init
Prototipo void SPI_Remappable_Init ();
Devolucion Nada.
es
Descripció Configura e inicializa el módulo SPI Remappable con la configuración
n predeterminada. SPI_Remappable_Init_Advancedo SPI_Remappable_I
nit_Initdebe llamarse antes de usar otras funciones de SPI Remappable
Library.
Los ajustes predeterminados son:
 modo maestro
 reloj fosc / 4
 reloj en estado inactivo bajo
 datos transmitidos en el borde bajo al alto
 datos de entrada muestreados en el medio del intervalo

selección de pin periférico esté marcada en el Administrador de bibliotecas y de
que se hayan asignado los pines apropiados.
Requiere Necesitará PIC MCU con SPI de hardware integrado y función extraíble.
Ejemplo // Inicialice el módulo SPI Remappable con la

configuración predeterminada
SPI_Remappable_Init ();
SPI_Remappable_Init_Advanced
Prototipo void SPI_Remappable_Init_Advanced (b> master_slav
unsigned short, corto sin signo data_sample, corto sin
signo clock_idle, corto sin signotransmit_edge);
Devolucio Nada.
nes
Descripci Configura e inicializa

ón el módulo SPI Remappable. SPI_Remappable_Init_Advancedo SPI_Rema
ppable_Initdebe llamarse antes de usar otras funciones de la Biblioteca SPI .

selección de pin periférico esté marcada en el Administrador de bibliotecas y de
que se hayan asignado los pines apropiados.
Parámetros mode, data_sample, clock_idley transmit_edgeconfigurar el

módulo SPI, y pueden tener los siguientes valores:
Modo de trabajo SPI:
Master
clock = _SPI_REMAPPABLE_MASTER_OSC_DIV4
Fosc/4
Master
Fosc/16
Master
Fosc/64
Master
clock
_SPI_REMAPPABLE_MASTER_TMR2
source
TMR2
Slave
select _SPI_REMAPPABLE_SLAVE_SS_ENABLE
enabled
Slave
select _SPI_REMAPPABLE_SLAVE_SS_DIS
disabled
Intervalo de muestreo de datos:
Input data
sampled in
_SPI_REMAPPABLE_DATA_SAMPLE_MIDDLE
middle of
interval
Input data
sampled at
_SPI_REMAPPABLE_DATA_SAMPLE_END
the end of
interval
SPI reloj estado inactivo:
Clock idle
_SPI_REMAPPABLE_CLK_IDLE_HIGH
HIGH
Clock idle
_SPI_REMAPPABLE_CLK_IDLE_LOW
LOW
Borde de transmisión:
Data _SPI_REMAPPABLE_LOW_2_HIGH
transmit
on low to
high edge
Data
transmit
_SPI_REMAPPABLE_HIGH_2_LOW
on high to
low edge
Requiere Necesita PIC MCU con SPI de hardware integrado y función extraíble.
Ejemplo // Establecer el tipo de programa en el que el usuario

está en la mitad del intervalo, el estado de ralentí del
reloj y los datos transmitidos de
menor a mayor borde: SPI_Remappable_Init_Advanced
(_SPI_REMAPPABLE_MASTER_OSC_DIV4,
_SPI_REMAPPABLE_DATA_SAM_PJP__PADER_P.P.P.P.P.P._P.P.
SPI_Remappable_Read
Prototipo SPI_Remappable_Read corto sin firmar ( buffer corto
sin firmar );

Parámetros:
 buffer: datos ficticios para la generación de reloj (consulte la
hoja de datos del dispositivo para los detalles de
implementación de los módulos SPI)
SPI debe ser inicializado y la comunicación establecida antes de usar esta
función. Consulte SPI_Remappable_Init_Advanced o SPI_Remappable_Init .

...
take = SPI_Remappable_Read (búfer);
SPI_Remappable_Write
Prototipo void SPI_Remappable_Write (datos cortos sin firmar);
Devoluciones Nada.
Descripción Escribe un byte dataen SSPBUF e inmediatamente inicia la transmisión.
SPI debe ser inicializado y la comunicación establecida antes de usar esta
función. Consulte SPI_Remappable_Init_Advanced o SPI_Remappable_Init .
Ejemplo SPI_Remappable_Write (1);
Biblioteca SPI Ethernet ENC28J60

El ENC28J60es un controlador Ethernet autónomo con un interfaz periférico serie
estándar de la industria (SPI). Está diseñado para servir como una interfaz de red
Ethernet para cualquier controlador equipado con SPI .
El ENC28J60cumple con todas las especificaciones IEEE 802.3. Incorpora una serie
de esquemas de filtrado de paquetes para limitar los paquetes entrantes. También
proporciona un módulo DMA interno para un rápido rendimiento de datos
y cálculos de suma de comprobación de IP asistidos por hardware . La
comunicación con el controlador host se implementa a través de dos pines de
interrupción y el SPI, con velocidades de datos de hasta 10 Mb / s. Se utilizan dos
pines dedicados para el enlace de LED y la indicación de actividad de la red.
Esta biblioteca está diseñada para simplificar el manejo del hardware subyacente
( ENC28J60). Funciona con cualquier PIC con SPI integrado y más de 4 Kb de
memoria ROM. Se recomienda un reloj de 38 a 40 MHz para obtener
un reloj SPI de 8 a 10 Mhz , de lo contrario, el PIC debe ser cronometrado
por ENC28J60la salida del reloj debido a su error de silicio en el hardware SPI . Si
intenta bajar la velocidad del reloj PIC, es posible que se cuelgue la placa o se
pierdan algunas solicitudes.
La biblioteca SPI Ethernet ENC28J60 admite:
 Protocolo IPv4.
 Peticiones UDP
 Cliente DNS
 Cliente UDP
 Cliente DHCP
Importante:
 Debido a las limitaciones de RAM / Flash de PIC16, la biblioteca

PIC16 NO tiene ARP , DNS , UDP y soporte de
cliente DHCP implementado.
 La variable de biblioteca global SPI_Ethernet_userTimerSecse utiliza
para realizar un seguimiento del tiempo para todas las
implementaciones de clientes ( ARP , DNS , UDP y DHCP ). Es
responsabilidad del usuario incrementar esta variable cada segundo en
su código si se utiliza alguno de los clientes.
 Para los usuarios avanzados, hay archivos de encabezado
( "__EthEnc28j60.h"y "__EthEnc28j60Private.h") en las carpetas Uses
\ P16 y Uses \ P18 del compilador con una descripción de todas las
rutinas y variables globales, relevantes para el usuario, implementadas
en la biblioteca SPI Ethernet ENC28J60.
 El módulo SPI de hardware apropiado debe inicializarse antes de usar
cualquiera de las rutinas de la biblioteca SPI Ethernet
ENC28J60. Consulte la biblioteca SPI .
 Para las MCU con dos módulos SPI es posible inicializar ambos y luego
cambiar usando la SPI_Set_Active()rutina.
Dependencias externas de la biblioteca SPI Ethernet ENC28J60

Las siguientes variables
deben definirse en
Descripci
todos los proyectos Ejemplos:
ón:
utilizando la biblioteca
SPI Ethernet ENC28J60:
Pin de
selección
extern sfr
sbitSPI_Ethernet_CS; de chip sbit SPI_Ethernet_CS atRC1_bit;
ENC28J60
.
Perno de
extern sfr reinicio
sbit SPI_Ethernet_Rst atRC0_bit;
sbitSPI_Ethernet_RST; ENC28J60
.
Dirección
del pin de
extern sfr
selección sbitSPI_Ethernet_CS_Direction at T
sbitSPI_Ethernet_CS_Dir
ection; de chip RISC1_bit;
ENC28J60
.
Dirección
extern sfr del pin de
sbitSPI_Ethernet_Rst_Direction at
sbitSPI_Ethernet_RST_Di reinicio TRISC0_bit;
rection; ENC28J60
.
Las siguientes rutinas deben

definirse en todos los proyectos
Descripción: Ejemplos:
utilizando la biblioteca SPI
Ethernet ENC28J60:
Consulte el
unsigned ejemplo de la
intSPI_Ethernet_UserTCP(unsigned biblioteca en la
Controlador
char *remoteHost, unsigned parte inferior
int remotePort, unsigned de solicitud
de esta página
intlocalPort, unsigned TCP.
para la
intreqLength, TEthPktFlags*flags);
implementación
del código.
Consulte el
intSPI_Ethernet_UserUDP(unsigned biblioteca en la
Controlador
int remotePort, unsigned de solicitudes
de esta página
intlocalPort, unsigned UDP.
para la
intreqLength, TEthPktFlags*flags);
implementación
del código.
PIC16 y PIC18:
 SPI_Ethernet_Init
 SPI_Ethernet_Enable
 SPI_Ethernet_Disable
 SPI_Ethernet_doPacket
 SPI_Ethernet_putByte
 SPI_Ethernet_putBytes
 SPI_Ethernet_putString
 SPI_Ethernet_putConstString
 SPI_Ethernet_putConstBytes
 SPI_Ethernet_getByte
 SPI_Ethernet_getBytes
 SPI_Ethernet_UserTCP
 SPI_Ethernet_UserUDP
Sólo PIC18:
 SPI_Ethernet_getIpAddress
 SPI_Ethernet_getGwIpAddress
 SPI_Ethernet_getDnsIpAddress
 SPI_Ethernet_getIpMask
 SPI_Ethernet_confNetwork
 SPI_Ethernet_arpResolve
 SPI_Ethernet_sendUDP
 SPI_Ethernet_dnsResolve
 SPI_Ethernet_initDHCP
 SPI_Ethernet_doDHCPLeaseTime
 SPI_Ethernet_renewDHCP
SPI_Ethernet_Init
Prototipo void SPI_Ethernet_Init ( unsigned char *
mac, unsigned char * ip, unsigned charfullDuplex);
Devolucione Nada.
s
Descripción Esta es la rutina del módulo MAC . Se inicializa

el ENC28J60controlador. Esta función se divide internamente
en 2 partes para ayudar al enlazador cuando se queda corto
de memoria.
ENC28J60 configuración del controlador (los parámetros que
no se mencionan aquí están configurados por defecto):
 Memoria RAM de lectura / escritura de
punteros en modo de incremento automático.
los valores predeterminados: CRC + MAC Unic
ast + MAC Broadcast en modo OR.
 Control de flujo con cuadros de pausa de TX y
RX en modo dúplex completo.
en 1518.
modo dúplex completo; 0x12en modo half
duplex.
duplex.
 La ventana de colisión está configurada 63en
modo semidúplex para acomodar
algunas ENC28J60revisiones de errores de silicio.
 La salida de CLKOUT está deshabilitada para
reducir la generación de EMI.
Parámetros:
 fullDuplex:Interruptor de modo dúplex
Ethernet. Valores válidos: 0(modo semidúplex)
y 1(modo dúplex completo).
 SPI_Ethernet_CS: Línea Chip Select

 SPI_Ethernet_CS_Direction: Dirección del pin
Chip Select
 SPI_Ethernet_RST: Restablecer línea
 SPI_Ethernet_RST_Direction: Dirección del pin
de reinicio

Ejemplo #define SPI_Ethernet_HALFDUPLEX 0

#define SPI_Ethernet_FULLDUPLEX 1
// mE ethernet NIC pinout

sfr sbit SPI_Ethernet_Rst en RC0_bit;
sfr sbit SPI_Ethernet_CS en RC1_bit;
sfr sbit SPI_Ethernet_Rst_Direction en TRISC0_bit;
sfr sbit SPI_Ethernet_CS_Direction en TRISC1_bit;
// terminar las definiciones de ethernet NIC
unsigned char myMacAddr [6] = {0x00, 0x14, 0xA5,

0x76, 0x19, 0x3f}; // mi dirección MAC
dirección IP
SPI1_Init ();
SPI_Ethernet_Init (myMacAddr, myIpAddr,
SPI_Ethernet_FULLDUPLEX);
SPI_Ethernet_Enable
Prototip void SPI_Ethernet_Enable ( unsigned char enFlt);
o
Devoluci Nada.
ones
Descripci Esta es la rutina del módulo MAC . Esta rutina permite el

ón tráfico de red apropiado en el ENC28J60módulo por medio de
sus filtros de recepción (unicast, multicast, broadcast, crc). El
tipo específico de tráfico de red se habilitará si se establece un
bit correspondiente del parámetro de entrada de esta
rutina. Por lo tanto, se puede habilitar más de un tipo de tráfico
de red al mismo tiempo. Para este propósito, las constantes de
biblioteca predefinidas (consulte la tabla a continuación) se
pueden ORed para formar el valor de entrada apropiado.
Parámetros:
 enFlt:tráfico de red / recibir banderas de
Po Másc Biblioteca
Descripción
Tráfico de
difusión MAC /
indicador de
filtro de
recepción. Cuan _SPI_Ethernet_BR
0 0x01
do se OADCAST
establece, el trá
fico de
transmisión MA
C se habilitará.
Tráfico de _SPI_Ethernet_MU
1 0x02
LTICAST
multidifusión M
AC / indicador
de filtro de
recepción.Cuan
do se
establece, se
habilitará el
tráfico de
multidifusión M
AC .
CRC marca
de verificación.
Cuando se
establece, los _SPI_Ethernet_CR
5 0x20
paquetes con C
elcampo CRC n
o válido se
descartarán.
Tráfico de
unidifusión MA
C / indicador de
filtro de
recepción. Cuan _SPI_Ethernet_UN
7 0x80
do se ICAST
establece, el trá
fico de
unidifusión MA
C se habilitará.
Nota :

el ENC28J60módulo, por
ejemplo Pattern Match, Magic
habilitar con esta rutina. Además, todos
los filtros, excepto CRC , habilitados
con esta rutina funcionarán en modo
OR, lo que significa que el paquete se
recibirá si alguno de los filtros
habilitados lo acepta.
interferirá con la habilitación /
inhabilitación de la lógica de recepción /
transmisión o cualquier otra parte
del ENC28J60módulo. El ENC28J60módulo
debe estar correctamente configurado
por medio de
la rutina SPI_Ethernet_Init .

inicializado. Ver SPI_Ethernet_Init .
Ejemplo SPI_Ethernet_Enable (_SPI_Ethernet_CRC |

_SPI_Ethernet_UNICAST); // habilitar el control de CRC y
el tráfico de unidifusión
SPI_Ethernet_Disable
Prototip void SPI_Ethernet_Disable ( unsigned char disFlt);
o
Devoluci Nada.
ones
Descripci Esta es la rutina del módulo MAC . Esta rutina desactiva el

ón tráfico de red apropiado en el ENC28J60módulo por medio de
tipo específico de tráfico de red se desactivará si se establece
un bit correspondiente del parámetro de entrada de esta
rutina. Por lo tanto, más de un tipo de tráfico de red se puede
desactivar al mismo tiempo. Para este propósito, las constantes
de biblioteca predefinidas (consulte la tabla a continuación) se
pueden ORed para formar el valor de entrada apropiado.
Parámetros:
Po Másc Biblioteca
Descripción
Tráfico de _SPI_Ethernet_BR
0 0x01
OADCAST
difusión MAC /
indicador de
filtro de
recepción. Cuan
do se
establece,el tráf
ico de
transmisión MA
C se
deshabilitará.
Tráfico de
multidifusión M
AC / indicador
de filtro de
recepción. Cuan
_SPI_Ethernet_MU
1 0x02 do se
LTICAST
establece, el trá
fico de
multidifusión M
AC se
deshabilitará.
CRC marca
de verificación.
Cuando se
establece,
la verificación C
_SPI_Ethernet_CR
5 0x20 RC se C
deshabilitará y
se aceptarán los
paquetes con
el campo CRC n
o válido .

Tráfico de
unidifusión MA
C / indicador de
filtro de
recepción. Cuan
_SPI_Ethernet_UN
7 0x80 do se
ICAST
establece, el trá
fico de
unidifusión MA
C se
deshabilitará.
Nota :
 Filtrado avanzado disponible en

el ENC28J60módulo, como Pattern
Match, Magic Packety Hash Tableno
puede ser deshabilitado por esta rutina.
interferirá con la habilitación /
inhabilitación de la lógica de recepción /
transmisión o cualquier otra parte
del ENC28J60módulo.
 El ENC28J60módulo debe estar
correctamente configurado por medio
de la rutina SPI_Ethernet_Init .

Ejemplo SPI_Ethernet_Disable (_SPI_Ethernet_CRC |

_SPI_Ethernet_UNICAST); // deshabilitar la comprobación
de CRC y el tráfico de unidifusión
SPI_Ethernet_doPacket
Prototipo unsigned char SPI_Ethernet_doPacket ();
Devoluciones  0 - tras el procesamiento exitoso de paquetes

(cero paquetes recibidos o recibidos paquete
procesado exitosamente).
corrupción del búfer. ENC28J60el controlador
transmisión IP ).
para la biblioteca.

siguiente manera:
 Las solicitudes de ARP e ICMP son contestadas
automáticamente.
 Tras la solicitud de TCP , se llama a la
función SPI_Ethernet_UserTCPpara su posterior
procesamiento.
 cuando se solicita UDP , se llama a la
función SPI_Ethernet_UserUDPpara su
Nota: SPI_Ethernet_doPacket debe llamarse tan a

menudo como sea posible en el código del usuario.

Ejemplo if (SPI_Ethernet_doPacket () == 0) (1) { //

procesar paquetes recibidos
...
}
SPI_Ethernet_putByte
Prototipo void SPI_Ethernet_putByte ( unsigned char v);
Devoluciones Nada.

dirección señalada por el ENC28J60puntero de
escritura actual ( EWRPT).
Parámetros:


...
SPI_Ethernet_putByte (datos); // poner un byte en el
búfer ENC28J60
SPI_Ethernet_putBytes
Prototipo void SPI_Ethernet_putBytes ( unsigned char *
ptr, unsigned int n);
Devoluciones Nada.

solicitado de bytes en la ENC28J60RAM a partir de
la ubicación actual del ENC28J60puntero de escritura
( EWRPT).
Parámetros:
escribir en la ENC28J60 memoria RAM .


...
SPI_Ethernet_putBytes (buffer, 16); // poner una
matriz de RAM en el búfer ENC28J60
SPI_Ethernet_putConstBytes
Prototipo void SPI_Ethernet_putConstBytes ( const unsigned
Devoluciones Nada.

solicitado de const bytes en la ENC28J60RAM a partir de
( EWRPT).
Parámetros:
 ptr:Const buffer que contiene bytes para


...
SPI_Ethernet_putConstBytes (buffer, 16); // poner
una matriz const en el búfer ENC28J60
SPI_Ethernet_putString
Prototipo unsigned int SPI_Ethernet_putString ( unsigned
char * ptr);
Devoluciones Número de bytes escritos en la ENC28J60 memoria RAM .

cadena (excluyendo la terminación nula) en
la ENC28J60 RAM a partir de la ubicación actual
del ENC28J60puntero de escritura ( EWRPT).
Parámetros:
 ptr:cadena para escribir en
la ENC28J60 memoria RAM .


...
SPI_Ethernet_putString (buffer); // poner una cadena
de RAM en el búfer ENC28J60
SPI_Ethernet_putConstString
Prototipo unsigned int SPI_Ethernet_putConstString ( const
unsigned char * ptr);
Devoluciones Número de bytes escritos en la ENC28J60 memoria RAM .

Parámetros:


...
SPI_Ethernet_putConstString (buffer); // poner una
cadena constante en el búfer ENC28J60
SPI_Ethernet_getByte
Prototipo unsigned char SPI_Ethernet_getByte ();
Devoluciones Byte leído desde la ENC28J60 memoria RAM .

la dirección apuntada por el ENC28J60puntero de
lectura actual ( ERDPT).

...
buffer = SPI_Ethernet_getByte (); // leer un byte
desde el búfer ENC28J60
SPI_Ethernet_getBytes
Prototipo void SPI_Ethernet_getBytes ( unsigned char *
ptr, unsigned int addr, unsigned int n);
Devoluciones Nada.

bytes asimilados de la ENC28J60 RAM a partir de la
dirección dada. Si 0xFFFFse pasa el valor de como
parámetro de dirección, la lectura comenzará desde
la ubicación actual del ENC28J60puntero de lectura ( ERDPT).
Parámetros:
 addr: ENC28J60 Dirección de inicio
de RAM . Los valores válidos: 0.. 8192.


...
SPI_Ethernet_getBytes (buffer, 0x100, 16); // leer
16 bytes, comenzando desde la dirección 0x100
SPI_Ethernet_UserTCP
Prototipo unsigned int SPI_Ethernet_UserTCP ( unsigned
char * remoteHost, unsigned
int remotePort, unsigned int localPort, unsigned


SPI_Ethernet_get. El usuario coloca datos en el búfer de
transmisión mediante el uso de algunas de las rutinas
SPI_Ethernet_put. La función debe devolver la longitud en
bytes de la respuesta TCP / HTTP , o 0 si no hay nada
que transmitir. Si no hay necesidad de responder a
las solicitudes TCP / HTTP , simplemente defina esta
Parámetros:
solicitud TCP / HTTP .
de bits:
typedef struct {
familia PIC16)
} TEthPktFlags;
Nota: El código fuente de la función se proporciona

con proyectos de ejemplo apropiados. El código debe ser
ajustado por el usuario para lograr la respuesta deseada.


SPI_Ethernet_UserUDP
Prototipo unsigned int SPI_Ethernet_UserUDP ( unsigned
char * remoteHost, unsigned
int remotePort, unsigned int destPort, unsigned


SPI_Ethernet_get. El usuario coloca datos en el búfer de
transmisión mediante el uso de algunas de las rutinas
SPI_Ethernet_put. La función debe devolver la longitud en
bytes de la respuesta UDP , o 0 si no hay nada que
transmitir. Si no necesita responder a las solicitudes UDP ,
simplemente defina esta función con un retorno (0) como
una sola declaración.
Parámetros:
 destPort: Puerto al que se envía la solicitud.
de bits:
typedef struct {
relevante para UDP)
familia PIC16)
} TEthPktFlags;



SPI_Ethernet_getIpAddress
Prototipo unsigned char * SPI_Ethernet_getIpAddress ();

presente en la red para obtener la dirección IP asignada .

ningún caso!
Disponible solo para MCU de la familia PIC18 .

IP de usuario
...
memcpy (ipAddr, SPI_Ethernet_getIpAddress (), 4); //
obtener la dirección IP
SPI_Ethernet_getGwIpAddress
Prototipo unsigned char * SPI_Ethernet_getGwIpAddress ();
Devoluciones Puntero a la variable global que contiene la dirección IP de

la puerta de enlace .

la puerta de enlace asignada .


...
memcpy (gwIpAddr, SPI_Ethernet_getGwIpAddress (),
4); // obtener la dirección IP de la puerta de
enlace
SPI_Ethernet_getDnsIpAddress
Prototipo unsigned char * SPI_Ethernet_getDnsIpAddress ()

del DNS .
Descripción esta rutina debe usarse cuando el servidor DHCP está
presente en la red para obtener la dirección IPasignada
del DNS .

ningún caso!


IP de usuario DNS
...
memcpy (dnsIpAddr, SPI_Ethernet_getDnsIpAddress (),
4); // obtener la dirección del servidor DNS
SPI_Ethernet_getIpMask
Prototipo unsigned char * SPI_Ethernet_getIpMask ()

subred IP .

presente en la red para recuperar la máscara de

ningún caso!


...
memcpy (IpMask, SPI_Ethernet_getIpMask (), 4); //
obtener máscara de subred IP
SPI_Ethernet_confNetwork
Prototipo void SPI_Ethernet_confNetwork ( char *
ipMask, char * gwIpAddr, char * dnsIpAddr);
Devoluciones Nada.

Parámetros:

se utiliza el módulo DHCP . De lo contrario, DHCP anulará
esta configuración.

Ejemplo char ipMask [4] = {255, 255, 255, 0}; // máscara de

red (por ejemplo: 255.255.255.0)
char gwIpAddr [4] = {192, 168, 1, 1}; // dirección
IP de la puerta de enlace (enrutador)
char dnsIpAddr [4] = {192, 168, 1, 1}; // dirección
IP del servidor DNS
...
SPI_Ethernet_confNetwork (ipMask, gwIpAddr,
dnsIpAddr); // establecer los parámetros de
configuración de red
SPI_Ethernet_arpResolve
Prototipo unsigned char * SPI_Ethernet_arpResolve ( unsigned
char * ip, unsigned char tmax);


resolvió ladirección IP solicitada , se utiliza una entrada de
efectivo de ARP , consulte
el "eth_enc28j60LibDef.h"archivo de encabezado en la
carpeta Uses / P18 del compilador.
Parámetros:
respuesta.

este tiempo.


Dirección IP
...
SPI_Ethernet_arpResolve (IpAddr, 5); // obtener la
dirección MAC detrás de la dirección IP anterior,
espere 5 segundos para la respuesta
SPI_Ethernet_sendUDP
Prototipo unsigned char SPI_Ethernet_sendUDP ( unsigned
char * destIP, unsigned int sourcePort, unsigned
int destPort, unsigned char * pkt, unsigned
intpktLen);
Devoluciones  1- El paquete UDP se envió con éxito.


Parámetros:
origen UDP local .
transmitir.


...
SPI_Ethernet_sendUDP (IpAddr, 10001, 10001, "Hola",
5); // enviar el mensaje de saludo a la dirección IP
anterior, desde el puerto UDP 10001 al puerto UDP
10001
SPI_Ethernet_dnsResolve
Prototipo unsigned char * SPI_Ethernet_dnsResolve ( unsigned
char * host, unsigned chartmax);

solicitado.

como puerto DNS .
Parámetros:
respuesta.
Nota :



...
// servidor SNTP:
memcpy (remoteHostIpAddr, SPI_Ethernet_dnsResolve
("swisstime.ethz.ch", 5), 4);
SPI_Ethernet_initDHCP
Prototipo unsigned char SPI_Ethernet_initDHCP ( unsigned
char tmax);
Devolucion  1 - Los parámetros de red se obtuvieron con

es éxito.

una solicitud DHCP para los parámetros de red ( IP , puerta
de enlace, direcciones DNS y máscara de subred IP ) y
espera la respuesta de DHCP . Si los parámetros solicitados
se obtuvieron con éxito, sus valores se almacenan en las
variables globales de la biblioteca.
Estos parámetros se pueden obtener utilizando las rutinas de
obtención de IP de la biblioteca adecuadas :
 SPI_Ethernet_getIpAddress -
busca la dirección IP .
 SPI_Ethernet_getGwIpAddress -
busca la dirección IP de la puerta de enlace .
 SPI_Ethernet_getDnsIpAddress - obtiene la direc
ción IP del DNS .
 SPI_Ethernet_getIpMask - buscar máscara de
subred IP .
servidor DHCP .
Parámetros:
respuesta.
Nota :

del DNS . Los paquetes entrantes se procesarán
normalmente durante este tiempo.
 Cuando se usa el módulo DHCP , la variable de
biblioteca global SPI_Ethernet_userTimerSecse

Ejemplo ...
SPI_Ethernet_initDHCP (5); // obtener la configuración
de red del servidor DHCP, espere 5 segundos para
obtener la respuesta
...
SPI_Ethernet_doDHCPLeaseTime
Prototipo unsigned char SPI_Ethernet_doDHCPLeaseTime ();

expirado.
hora de renovarlo.



...
if (SPI_Ethernet_doDHCPLeaseTime ())
dirección IP
}
SPI_Ethernet_renewDHCP
Prototipo unsigned char SPI_Ethernet_renewDHCP ( unsigned
char tmax);

expirada).

Parámetros:
respuesta.


...
if (SPI_Ethernet_doDHCPLeaseTime ())
SPI_Ethernet_renewDHCP (5); // es hora de
renovar el arrendamiento de la dirección IP, con 5
segundos para una respuesta
...
}
Este código muestra cómo usar la mini biblioteca de Ethernet:
puerto
principal HTML.
#include "__EthEnc28j60.h"
// indicadores de configuración de dúplex

#define Spi_Ethernet_HALFDUPLEX 0x00 // half duplex
#define Spi_Ethernet_FULLDUPLEX 0x01 // full duplex
// mE ehternet NIC pinout
sfr sbit SPI_Ethernet_Rst en RC0_bit;
sfr sbit SPI_Ethernet_CS en RC1_bit;
sfr sbit SPI_Ethernet_Rst_Direction en TRISC0_bit;
sfr sbit SPI_Ethernet_CS_Direction en TRISC1_bit;
/ ************************************************** ***********
* /
encabezado HTTP
HTML MIME type
TEXT MIME type
/ *
*
* /
<h1> Mini servidor web PIC + ENC28J60 </h1>
family: terminal;">
<script>
var str, i;
str = "";
para (i = 0; i <8; i ++)
str + = "</td> </tr>";}
</script>
";

<script>
var str, i;
str = "";
para (i = 0; i <8; i ++)
</script>
</BODY> </HTML>
";
/ ***********************************
* RAM variables
* /
no firmada char myIpAddr [4] = {192, 168, 20, 60};
// mi dirección IP
/ *******************************************
* funciones
* /
/ *
* ponga la cadena constante apuntada por s al búfer de transmisión ENC.
* /
{
mientras (* s)
{
Spi_Ethernet_putByte (* s ++);
ctr ++;
}
retorno (ctr);
} * /
/ *
* será mucho más rápido usar la rutina Spi_Ethernet_putConstString de la
biblioteca
será un poco
anterior
*
* /
#define putConstString SPI_Ethernet_putConstString
/ *
* poner la cadena apuntada por s al búfer de transmisión ENC
* /
{
mientras (* s)
{
Spi_Ethernet_putByte (* s ++);
ctr ++;
}
retorno (ctr);
} * /
/ *
* será mucho más rápido usar la rutina Spi_Ethernet_putString de la
biblioteca
un poco
anterior
*
* /
#define putString SPI_Ethernet_putString
/ *
Spi_Ethernet_getByte ()
* el usuario pone datos en el búfer de transmisión mediante llamadas
sucesivas a Spi_Ethernet_putByte ()
*
declaración
*
* /
unsigned int SPI_Ethernet_UserTCP ( unsigned char * remoteHost, unsigned
int remotePort, unsigned int localPort, unsigned int reqLength,
{
unsigned int len = 0; // mi longitud de
respuesta
unsigned int i; // entero de propósito
general

respuesta?
el indicador canClose no se restablece aquí
// flags-> canClose = 0; // 0 - no cerrar socket

{
retorno (0);
}

importa aquí
para (i = 0; i <10; i ++)
{
getRequest [i] = SPI_Ethernet_getByte ();
}
getRequest [i] = 0;

{
retorno (0);
}

hecha

de transmisión
{

encabezado HTTP
texto tipo MIME




}
{

{
máscara de bits
}
}
hacer por defecto
{
encabezado HTTP
HTML MIME type
HTML primera parte
}

}
/ *
Spi_Ethernet_getByte ()
* el usuario pone datos en el búfer de transmisión mediante llamadas
sucesivas a Spi_Ethernet_putByte ()
*
declaración
*
* /
unsigned int SPI_Ethernet_UserUDP ( unsigned char * remoteHost, unsigned
int remotePort, unsigned int destPort, unsigned int reqLength,
{
mi respuesta

dirección IP
dyna [3] = '.' ;
dyna [7] = '.' ;
dyna [11] = '.' ;

separador

dyna [21] = '[';
dyna [27] = ']';
dyna [28] = 0;


SPI_Ethernet_putBytes (dyna, 28);

while (reqLength--)
{
SPI_Ethernet_putByte (toupper (SPI_Ethernet_getByte ()));
}

de la respuesta UDP
}
/ *
* Entrada principal
* /
void main ()
{
ANSEL = 0x0C; // se utilizarán los convertidores AN2 y
AN3
C2ON_bit = 0;
PORTA = 0;
TRISA = 0xff; // establece PORTA como entrada para ADC

digital
PORTB = 0;
botones
PORTD = 0;
/ *
* inicia ENC28J60 con:
* bit de reinicio en RC0
* CS bit en RC1
* mi dirección MAC e IP
* duplex completo
* /
SPI1_Init ();
SPI_Ethernet_Init (myMacAddr, myIpAddr, Spi_Ethernet_FULLDUPLEX);

{
/ *
* /
SPI_Ethernet_doPacket (); // procesar los paquetes
entrantes de Ethernet
/ *
* Spi_Ethernet_doPacket () debe llamarse tan a menudo
como sea posible
* /
}
}
Conexión HW
Biblioteca SPI Ethernet ENC24J600
El ENC24J600es un controlador Ethernet autónomo con un interfaz periférico serie
estándar de la industria (SPI). Está diseñado para servir como una interfaz de red
Ethernet para cualquier controlador equipado con SPI .
El ENC24J600cumple con todos los IEEE especificaciones aplicables a 802.3 10Base-
T y 100Base-TX Ethernet. Incorpora una serie de esquemas de filtrado de paquetes
para limitar los paquetes entrantes. También proporciona un módulo DMA de 16
bits de ancho interno para un rápido rendimiento de datos y cálculos de suma de
comprobación de IP asistidos por hardware . La comunicación con el controlador
host se implementa a través de dos pines de interrupción y el SPI , con
velocidades de datos de 10/100 Mb / s. Se utilizan dos pines dedicados para
el enlace de LED y la indicación de actividad de la red.
Esta biblioteca está diseñada para simplificar el manejo del hardware subyacente
( ENC24J600). Funciona con cualquier PIC con SPI integrado y más de 4 Kb de
memoria ROM. Se recomienda un reloj de 38 a 40 MHz para obtener
un reloj SPI de 8 a 10 Mhz , de lo contrario, el PIC debe ser cronometrado
por ENC24J600la salida del reloj debido a su error de silicio en el hardware SPI . Si
intenta bajar la velocidad del reloj PIC, es posible que se cuelgue la placa o se
pierdan algunas solicitudes.
La biblioteca SPI Ethernet ENC24J600 admite:
 Módulos ENC424J600 y ENC624J600.
 Protocolo IPv4.
 Peticiones UDP
 Cliente DNS
 Cliente UDP
 Cliente DHCP
Importante:
 Debido a las limitaciones de RAM / Flash de PIC16, la biblioteca

PIC16 NO tiene ARP , DNS , UDP y soporte de
cliente DHCP implementado.
 La variable de biblioteca global SPI_Ethernet_24j600_userTimerSecse
utiliza para realizar un seguimiento del tiempo para todas las
implementaciones de clientes ( ARP , DNS , UDPy DHCP ). Es
responsabilidad del usuario incrementar esta variable cada segundo en
su código si se utiliza alguno de los clientes.
 Para usuarios avanzados, hay archivos de encabezado
( "__EthEnc24j600.h"y "__EthEnc24j600Private.h") en las carpetas
Uses \ P16 y Uses \ P18 del compilador con una descripción de todas
las rutinas y variables globales, relevantes para el usuario,
implementadas en la biblioteca SPI Ethernet ENC24J600.
 El módulo SPI de hardware adecuado debe inicializarse antes de
utilizar cualquiera de las rutinas de la Biblioteca SPI Ethernet
ENC24J600. Consulte la biblioteca SPI .
 Para las MCU con dos módulos SPI es posible inicializar ambos y luego
cambiar usando la SPI_Set_Active()rutina.
Dependencias externas de la librería SPI Ethernet ENC24J600

deben definirse en todos
Descrip
los proyectos utilizando Ejemplos:
ción:
SPI Ethernet ENC24J600
Library:
Pin de
extern sfr selección
sbit SPI_Ethernet_24j600_CS atRC1_
sbitSPI_Ethernet_24j600_C de chip bit;
S; ENC24J6
00.
Dirección
extern sfr del pin sbitSPI_Ethernet_24j600_CS_Directi
sbitSPI_Ethernet_24j600_C
de on at TRISC1_bit;
S_Direction;
selección
de chip
ENC24J6
00.
Las siguientes rutinas deben definirse

en todos los proyectos utilizando la Descripción: Ejemplos:
biblioteca SPI Ethernet ENC24J600:
Consulte el
intSPI_Ethernet_24j600_UserTCP(unsigned biblioteca en la
Controlador
intremotePort, unsigned de solicitud
de esta página
int localPort,unsigned TCP.
para la
int reqLength,TEthj600PktFlags *flags);
implementación
del código.
Consulte el
intSPI_Ethernet_24j600_UserUDP(unsigned biblioteca en la
Controlador
intremotePort, unsigned de solicitudes
de esta página
int localPort,unsigned UDP.
para la
int reqLength,TEthj600PktFlags *flags);
implementación
del código.
PIC16 y PIC18:
 SPI_Ethernet_24j600_Init
 SPI_Ethernet_24j600_Enable
 SPI_Ethernet_24j600_Disable
 SPI_Ethernet_24j600_doPacket
 SPI_Ethernet_24j600_putByte
 SPI_Ethernet_24j600_putBytes
 SPI_Ethernet_24j600_putString
 SPI_Ethernet_24j600_putConstString
 SPI_Ethernet_24j600_putConstBytes
 SPI_Ethernet_24j600_getByte
 SPI_Ethernet_24j600_getBytes
 SPI_Ethernet_24j600_UserTCP
 SPI_Ethernet_24j600_UserUDP
Sólo PIC18:
 SPI_Ethernet_24j600_getIpAddress
 SPI_Ethernet_24j600_getGwIpAddress
 SPI_Ethernet_24j600_getDnsIpAddress
 SPI_Ethernet_24j600_getIpMask
 SPI_Ethernet_24j600_confNetwork
 SPI_Ethernet_24j600_arpResolve
 SPI_Ethernet_24j600_sendUDP
 SPI_Ethernet_24j600_dnsResolve
 SPI_Ethernet_24j600_initDHCP
 SPI_Ethernet_24j600_doDHCPLeaseTime
 SPI_Ethernet_24j600_renewDHCP
SPI_Ethernet_24j600_Init
Prototipo void SPI_Ethernet_24j600_Init ( unsigned char *
mac, unsigned char * ip, configuración de char sin
signo );
Devolucio Nada.
nes
Descripció Esta es la rutina del módulo MAC . Se inicializa

n el ENC24J600controlador. Esta función se divide internamente
en 2 partes para ayudar al enlazador cuando se queda corto
de memoria.
ENC24J600 configuración del controlador (los parámetros que
no se mencionan aquí están configurados por defecto):

 Memoria RAM de lectura / escritura de punteros
en modo de incremento automático.
los valores predeterminados: CRC + MAC Unicas
t + MAC Broadcast en modo OR.
 Control de flujo con cuadros de pausa de TX y RX
en modo dúplex completo.
en 1518.
modo dúplex completo; 0x12en modo half duplex.
duplex.
 La ventana de colisión está configurada 63en
modo semidúplex para acomodar
algunas ENC24J600revisiones de errores de silicio.
 La salida de CLKOUT está deshabilitada para
reducir la generación de EMI.
Parámetros:
 configuration:Configuración de negociación de
Ethernet, dúplex y modo de velocidad. Para este
propósito, las constantes de la biblioteca
predefinidas (ver la lista a continuación) se
pueden combinar utilizando el AND lógico para
formar el valor apropiado:
Establecer
SPI_Ethernet_24j600_AUTO_NEGOTI
autonegociac
ATION
ión
Establecer
SPI_Ethernet_24j600_MANUAL_NEGO
negociación
TIATION
manual.
Establecer
modo medio SPI_Ethernet_24j600_HALFDUPLEX
dúplex
Establecer
modo dúplex SPI_Ethernet_24j600_FULLDUPLEX
completo
Fije la
velocidad de
SPI_Ethernet_24j600_SPD10
transmisión
de 10Mbps
Fije la
velocidad de
SPI_Ethernet_24j600_SPD100
transmisión
de 100Mbps
Nota :
 Es recomendable utilizar solo la configuración de

autonegociación. Si se utiliza la negociación
manual, también se debe configurar el modo
dúplex y el modo de velocidad.
 El modo dúplex y la velocidad pueden
configurarse solo cuando se utiliza la negociación
manual.
 SPI_Ethernet_24j600_CS: Línea Chip Select

 SPI_Ethernet_24j600_CS_Direction: Dirección
del pin Chip Select
Ejemplo #include "__EthEnc24J600.h"
// mE ethernet NIC pinout

sfr sbit SPI_Ethernet_24j600_CS en RC0_bit;
sfr sbit SPI_Ethernet_24j600_CS_Direction en RC1_bit;
unsigned char myMacAddr [6] = {0x00, 0x14, 0xA5, 0x76,

0x19, 0x3f}; // mi dirección MAC
dirección IP
SPI1_Init ();
SPI_Ethernet_24j600_Init (myMacAddr, myIpAddr,
SPI_Ethernet_24j600_MANUAL_NEGOTIATION &
SPI_Ethernet_24j600_FULLDUPLEX &
SPI_Ethernet_24j600_SPD100);
SPI_Ethernet_24j600_Enable
Prototip void SPI_Ethernet_24j600_Enable ( unsigned int enFlt);
o
Devoluc Nada.
iones
Descrip Esta es la rutina del módulo MAC . Esta rutina permite el tráfico
ción de red apropiado en el ENC24J600módulo por medio de sus filtros
de recepción (unicast, multicast, broadcast, crc). El tipo
específico de tráfico de red se habilitará si se establece un bit
correspondiente del parámetro de entrada de esta rutina. Por lo
tanto, se puede habilitar más de un tipo de tráfico de red al
mismo tiempo. Para este propósito, las constantes de biblioteca
Parámetros:
 enFlt:tráfico de red / recibir banderas de filtro. Cada
bit corresponde al filtro de tráfico / recepción de red
apropiado:
Po Másc Biblioteca predefinida
Descripción
co ara const
Tráfico de
difusión MAC
/ indicador de _SPI_Ethernet_24j6
0 0x01
00_BROADCAST
filtro de
recepción. Cua
ndo se
establece, eltr
áfico de
transmisión M
AC se
habilitará.
Tráfico de
multidifusión
MAC /
indicador de
filtro de
recepción. Cua _SPI_Ethernet_24j6
1 0x02
ndo se 00_MULTICAST
establece,se
habilitará el
tráfico de
multidifusión
MAC .
CRC marca
de verificación
. Cuando se
establece, los _SPI_Ethernet_24j6
5 0x20
paquetes con 00_CRC
el campo CRC
no válido se
descartarán.
Tráfico de
unidifusión M
AC / indicador
de filtro de _SPI_Ethernet_24j6
7 0x80
00_UNICAST
recepción. Cua
ndo se
establece, eltr
áfico de
unidifusión M
AC se
habilitará.
Nota :

el ENC24J600módulo, por
ejemplo Pattern Match, Magic
Packety Hash Tableno se puede habilitar
con esta rutina. Además, todos los
filtros, excepto CRC , habilitados con
esta rutina funcionarán en modo OR, lo
que significa que el paquete se recibirá si
alguno de los filtros habilitados lo
acepta.
 Esta rutina cambiará la configuración del
filtro de recepción sobre la marcha. De
ninguna manera, no interferirá con la
habilitación / inhabilitación de la lógica
de recepción / transmisión o cualquier
otra parte
del ENC24J600módulo. El ENC24J600módul
o debería estar correctamente
la rutina SPI_Ethernet_24j600_Init .
Requier El módulo de Ethernet tiene que ser

e inicializado. Ver SPI_Ethernet_24j600_Init .
Ejemplo SPI_Ethernet_24j600_Enable (_SPI_Ethernet_24j600_CRC |

_SPI_Ethernet_24j600_UNICAST); // habilitar el control de
CRC y el tráfico de unidifusión
SPI_Ethernet_24j600_Disable
Prototip void SPI_Ethernet_24j600_Disable ( unsigned
o int disFlt);
Devoluc Nada.
iones
Descrip Esta es la rutina del módulo MAC . Esta rutina desactiva el

ción tráfico de red apropiado en el ENC24J600módulo por medio de
tipo específico de tráfico de red se desactivará si se establece un
bit correspondiente del parámetro de entrada de esta rutina. Por
lo tanto, más de un tipo de tráfico de red se puede desactivar al
mismo tiempo. Para este propósito, las constantes de biblioteca
Parámetros:
Po Másc Biblioteca predefinida
Descripción
co ara const
Tráfico de
difusión MAC
/ indicador de
filtro de
recepción. Cua
_SPI_Ethernet_24j6
0 0x01 ndo se
00_BROADCAST
establece, el t
ráfico de
transmisión M
AC se
deshabilitará.
Tráfico de
multidifusión
MAC /
indicador de
filtro de
recepción. Cua _SPI_Ethernet_24j6
1 0x02
ndo se 00_MULTICAST
establece, el t
ráfico de
multidifusión
MAC se
deshabilitará.
CRC marca
de verificación _SPI_Ethernet_24j6
5 0x20
. Cuando se 00_CRC
establece,
la verificación
CRC se
deshabilitará y
se aceptarán
los paquetes
con
el campo CRC
no válido .
Tráfico de
unidifusión M
AC / indicador
de filtro de
recepción. Cua
_SPI_Ethernet_24j6
7 0x80 ndo se
00_UNICAST
establece, el t
ráfico de
unidifusión M
AC se
deshabilitará.
Nota :
 Filtrado avanzado disponible en

el ENC24J600módulo, como Pattern
Match, Magic Packety Hash Tableno
puede ser deshabilitado por esta rutina.
 Esta rutina cambiará la configuración del
filtro de recepción sobre la marcha. De
ninguna manera, no interferirá con la
habilitación / inhabilitación de la lógica
de recepción / transmisión o cualquier
otra parte del ENC24J600módulo.
 El ENC24J600módulo debería estar
correctamente configurado por medio de
la rutina SPI_Ethernet_24j600_Init .
Requier El módulo de Ethernet tiene que ser

e inicializado. Ver SPI_Ethernet_24j600_Init .
Ejemplo SPI_Ethernet_24j600_Disable (_SPI_Ethernet_24j600_CRC |

_SPI_Ethernet_24j600_UNICAST); // deshabilitar la
comprobación de CRC y el tráfico de unidifusión
SPI_Ethernet_24j600_doPacket
Prototipo unsigned char SPI_Ethernet_24j600_doPacket ();
Devoluciones  0 - tras el procesamiento exitoso de paquetes

(cero paquetes recibidos o recibidos paquete
procesado exitosamente).
corrupción del búfer. ENC24J600el controlador
transmisión IP ).
para la biblioteca.

siguiente manera:
 Las solicitudes de ARP e ICMP son contestadas
automáticamente.
 tras la solicitud de TCP , se llama a la
función SPI_Ethernet_24j600_UserTCPpara su
 tras la solicitud de UDP , se llama a la
función SPI_Ethernet_24j600_UserUDPpara su
Nota: SPI_Ethernet_24j600_doPacket debe llamarse

tan a menudo como sea posible en el código del usuario.

inicializado. Ver SPI_Ethernet_24j600_Init .
Ejemplo if (SPI_Ethernet_24j600_doPacket () == 0) (1) { //

procesar paquetes recibidos
...
}
SPI_Ethernet_24j600_putByte
Prototipo void SPI_Ethernet_24j600_putByte ( unsigned
char v);
Devoluciones Nada.

dirección señalada por el ENC24J600puntero de
escritura actual ( EWRPT).
Parámetros:

...
SPI_Ethernet_24j600_putByte (datos); // poner un
byte en el búfer ENC24J600
SPI_Ethernet_24j600_putBytes
Prototipo void SPI_Ethernet_24j600_putBytes ( unsigned
Devoluciones Nada.

solicitado de bytes en la ENC24J600 RAM apartir de
( EWRPT).
Parámetros:


...
SPI_Ethernet_24j600_putBytes (buffer, 16); // poner
una matriz de RAM en el búfer ENC24J600
SPI_Ethernet_24j600_putConstBytes
Prototipo void SPI_Ethernet_24j600_putConstBytes ( const
unsigned char * ptr, unsigned int n);
Devoluciones Nada.

solicitado de const bytes en la ENC24J600 RAM apartir de
( EWRPT).
Parámetros:
 ptr:Const buffer que contiene bytes para

...
SPI_Ethernet_24j600_putConstBytes (buffer, 16); //
poner una matriz const en el búfer ENC24J600
SPI_Ethernet_24j600_putString
Prototipo unsigned int SPI_Ethernet_24j600_putString
( unsigned char * ptr);
Devoluciones Número de bytes escritos en la ENC24J600 memoria

RAM .

cadena (excluyendo la terminación nula) en
Parámetros:
 ptr:cadena para escribir en


...
SPI_Ethernet_24j600_putString (buffer); // poner una
cadena de RAM en el búfer ENC24J600
SPI_Ethernet_24j600_putConstString
Prototipo unsigned int SPI_Ethernet_24j600_putConstString
( const unsigned char * ptr);
Devoluciones Número de bytes escritos en la ENC24J600 memoria

RAM .

Parámetros:


...
SPI_Ethernet_24j600_putConstString (buffer); //
poner una cadena constante en el búfer ENC24J600
SPI_Ethernet_24j600_getByte
Prototipo unsigned char SPI_Ethernet_24j600_getByte ();
Devoluciones Byte leído desde la ENC24J600 memoria RAM .

la dirección apuntada por el ENC24J600puntero de
lectura actual ( ERDPT).


...
buffer = SPI_Ethernet_24j600_getByte (); // leer un
byte de búfer ENC24J600
SPI_Ethernet_24j600_getBytes
Prototipo void SPI_Ethernet_24j600_getBytes ( unsigned
char * ptr, unsigned int addr, unsigned int n);
Devoluciones Nada.

bytes asimilados de la ENC24J600 RAM a partir de la
dirección dada. Si 0xFFFFse pasa el valor de como
parámetro de dirección, la lectura comenzará desde
la ubicación actual del ENC24J600puntero de lectura
( ERDPT).
Parámetros:
 addr: ENC24J600 Dirección de inicio
de RAM . Los valores válidos: 0.. 8192.


...
SPI_Ethernet_24j600_getBytes (buffer, 0x100, 16); //
leer 16 bytes, comenzando desde la dirección 0x100
SPI_Ethernet_24j600_UserTCP
Prototipo unsigned int SPI_Ethernet_24j600_UserTCP
( unsigned char * remoteHost, unsigned
int remotePort, unsigned int localPort, unsigned
int reqLength, TEthj600PktFlags * flags);


SPI_Ethernet_24j600_get. El usuario coloca datos en el
búfer de transmisión utilizando algunas de las rutinas
SPI_Ethernet_24j600_put. La función debe devolver la
longitud en bytes de la respuesta TCP / HTTP , o 0 si no
hay nada que transmitir. Si no hay necesidad de responder
a las solicitudes TCP / HTTP , simplemente defina esta
Parámetros:
solicitud TCP .
de bits:
typedef struct {
familia PIC16)
} TEthj600PktFlags;
Nota: El código fuente de la función se proporciona

con proyectos de ejemplo apropiados. El código debe ser
ajustado por el usuario para lograr la respuesta deseada.


SPI_Ethernet_24j600_UserUDP
Prototipo unsigned int SPI_Ethernet_24j600_UserUDP
( unsigned char * remoteHost, unsigned
int remotePort, unsigned int destPort, unsigned
int reqLength, TEthj600PktFlags * flags);


SPI_Ethernet_24j600_get. El usuario coloca datos en el
búfer de transmisión utilizando algunas de las rutinas
SPI_Ethernet_24j600_put. La función debe devolver la
longitud en bytes de la respuesta UDP , o 0 si no hay nada
que transmitir. Si no necesita responder a
las solicitudes UDP , simplemente defina esta función con
un retorno (0) como una sola declaración.
Parámetros:
solicitud UDP .
de bits:
typedef struct {
relevante para UDP)
familia PIC16)
} TEthj600PktFlags;



SPI_Ethernet_24j600_getIpAddress
Prototipo unsigned char * SPI_Ethernet_24j600_getIpAddress
();

presente en la red para obtener ladirección IP asignada .

la dirección IP de la ubicación de RAM quedevuelve esta
ningún caso!


IP de usuario
...
memcpy (ipAddr, SPI_Ethernet_24j600_getIpAddress (),
4); // obtener la dirección IP
SPI_Ethernet_24j600_getGwIpAddress
Prototipo unsigned char * SPI_Ethernet_24j600_getGwIpAddress
();
Devoluciones Puntero a la variable global que contiene la dirección IP de

la puerta de enlace .

la puerta de enlace asignada .


...
memcpy (gwIpAddr, SPI_Ethernet_24j600_getGwIpAddress
(), 4); // obtener la dirección IP de la puerta de
enlace
SPI_Ethernet_24j600_getDnsIpAddress
Prototipo unsigned char *
SPI_Ethernet_24j600_getDnsIpAddress ()

del DNS .
Descripción esta rutina debe usarse cuando el servidor DHCP está

presente en la red para obtener la dirección IP asignada
del DNS .

ningún caso!


IP de usuario DNS
...
memcpy (dnsIpAddr,
SPI_Ethernet_24j600_getDnsIpAddress (), 4); //
obtener la dirección del servidor DNS
SPI_Ethernet_24j600_getIpMask
Prototipo unsigned char * SPI_Ethernet_24j600_getIpMask ()

subred IP .

presente en la red para recuperar lamáscara de

la dirección IP de la ubicación de RAM quedevuelve esta
ningún caso!


...
memcpy (IpMask, SPI_Ethernet_24j600_getIpMask (),
4); // obtener máscara de subred IP
SPI_Ethernet_24j600_confNetwork
Prototipo void SPI_Ethernet_24j600_confNetwork ( char *
ipMask, char * gwIpAddr, char * dnsIpAddr);
Devoluciones Nada.

Parámetros:

se utiliza el módulo DHCP . De lo contrario, DHCP anulará
esta configuración.

Ejemplo char ipMask [4] = {255, 255, 255, 0}; // máscara de

red (por ejemplo: 255.255.255.0)
char gwIpAddr [4] = {192, 168, 1, 1}; // dirección
IP de la puerta de enlace (enrutador)
char dnsIpAddr [4] = {192, 168, 1, 1}; // dirección
IP del servidor DNS
...
SPI_Ethernet_24j600_confNetwork (ipMask, gwIpAddr,
dnsIpAddr); // establecer los parámetros de
configuración de red
SPI_Ethernet_24j600_arpResolve
Prototipo unsigned char * SPI_Ethernet_24j600_arpResolve
( unsigned char * ip, unsigned char tmax);


resolvió la dirección IPsolicitada , se utiliza una entrada de
efectivo de ARP , consulte el "__EthEnc24j600.h"archivo
de encabezado en la carpeta Uses / P18 del compilador.
Parámetros:
respuesta.

este tiempo.


Dirección IP
...
SPI_Ethernet_24j600_arpResolve (IpAddr, 5); //
obtener la dirección MAC detrás de la dirección IP
anterior, espere 5 segundos para la respuesta
SPI_Ethernet_24j600_sendUDP
Prototipo unsigned char SPI_Ethernet_24j600_sendUDP
( unsigned char * destIP, unsigned
int sourcePort, unsigned int destPort, unsigned
char * pkt, unsigned intpktLen);
Devoluciones  1- El paquete UDP se envió con éxito.


Parámetros:
origen UDP local .
transmitir.


...
SPI_Ethernet_24j600_sendUDP (IpAddr, 10001, 10001,
"Hola", 5); // enviar el mensaje de saludo a la
dirección IP anterior, desde el puerto UDP 10001 al
puerto UDP 10001
SPI_Ethernet_24j600_dnsResolve
Prototipo unsigned char * SPI_Ethernet_24j600_dnsResolve
( unsigned char * host, unsigned char tmax);

solicitado.

como puerto DNS .
Parámetros:
respuesta.
Nota :


...
// servidor SNTP:
memcpy (remoteHostIpAddr,
SPI_Ethernet_24j600_dnsResolve ("swisstime.ethz.ch",
5), 4);
SPI_Ethernet_24j600_initDHCP
Prototipo unsigned char SPI_Ethernet_24j600_initDHCP
( unsigned char tmax);
Devoluciones  1 - Los parámetros de red se obtuvieron con

éxito.

una solicitud DHCP para los parámetros de red ( IP ,
puerta de enlace, direcciones DNS y máscara de
subred IP ) y espera la respuesta de DHCP . Si los
parámetros solicitados se obtuvieron con éxito, sus valores
se almacenan en las variables globales de la biblioteca.
Estos parámetros se pueden obtener utilizando las rutinas
de obtención de IP de la biblioteca adecuadas :
 SPI_Ethernet_24j600_getIpAddress -
busca la dirección IP .
 SPI_Ethernet_24j600_getGwIpAddress -
buscar la dirección IP de la puerta de enlace .
 SPI_Ethernet_24j600_getDnsIpAddress -
busca la dirección IP del DNS .
 SPI_Ethernet_24j600_getIpMask -
buscar máscara de subred IP .
servidor DHCP .
Parámetros:
respuesta.
Nota :

 Cuando se usa el módulo DHCP , la variable de
biblioteca
global SPI_Ethernet_24j600_userTimerSecse

Ejemplo ...
SPI_Ethernet_24j600_initDHCP (5); // obtener la
configuración de red del servidor DHCP, espere 5
segundos para obtener la respuesta
...
SPI_Ethernet_24j600_doDHCPLeaseTime
Prototipo unsigned char SPI_Ethernet_24j600_doDHCPLeaseTime
();

expirado.
hora de renovarlo.



...
if (SPI_Ethernet_24j600_doDHCPLeaseTime ())
dirección IP
}
SPI_Ethernet_24j600_renewDHCP
Prototipo unsigned char SPI_Ethernet_24j600_renewDHCP
( unsigned char tmax);
expirada).

Parámetros:
respuesta.


...
if (SPI_Ethernet_24j600_doDHCPLeaseTime ())
SPI_Ethernet_24j600_renewDHCP (5); // es hora de
renovar el arrendamiento de la dirección IP, con 5
segundos para una respuesta
...
}
Este código muestra cómo usar la mini biblioteca de Ethernet:
puerto
principal HTML.
#include "__EthEnc24j600.h"
// mE ehternet NIC pinout

sfr sbit SPI_Ethernet_24j600_CS en RC1_bit;
sfr sbit SPI_Ethernet_24j600_CS_Direction en TRISC1_bit;
/ ************************************************** ***********
* /
encabezado HTTP
HTML MIME type
TEXT MIME type
/ *
*
* /
<h1> Mini servidor web PIC + ENC24J600 </h1>
family: terminal;">
<script>
var str, i;
str = "";
para (i = 0; i <8; i ++)
str + = "</td> </tr>";}
</script>
";

<script>
var str, i;
str = "";
para (i = 0; i <8; i ++)
</script>
</BODY> </HTML>
";
/ ***********************************
* RAM variables
* /
no firmada char myIpAddr [4] = {192, 168, 20, 60};
// mi dirección IP
/ *******************************************
* funciones
* /
/ *
* ponga la cadena constante apuntada por s al búfer de transmisión ENC.
* /
{
mientras (* s)
{
SPI_Ethernet_24j600_putByte (* s ++);
ctr ++;
}
retorno (ctr);
} * /
/ *
* será mucho más rápido usar la rutina SPI_Ethernet_24j600_putConstString
de la biblioteca
será un poco
anterior
*
* /
#define putConstString SPI_Ethernet_24j600_putConstString
/ *
* poner la cadena apuntada por s al búfer de transmisión ENC
* /
{
mientras (* s)
{
SPI_Ethernet_24j600_putByte (* s ++);
ctr ++;
}
retorno (ctr);
} * /
/ *
* será mucho más rápido usar la rutina SPI_Ethernet_24j600_putString de
la biblioteca
un poco
anterior
*
* /
#define putString SPI_Ethernet_24j600_putString
/ *
SPI_Ethernet_24j600_getByte ()
sucesivas a SPI_Ethernet_24j600_putByte ()
*
declaración
*
* /
unsigned int SPI_Ethernet_24j600_UserTCP ( unsigned char * remoteHost,
unsigned int remotePort, unsigned int localPort, unsigned int reqLength,
{
unsigned int len = 0; // mi longitud de
respuesta
unsigned int i; // entero de propósito
general

respuesta?
el indicador canClose no se restablece aquí
// flags-> canClose = 0; // 0 - no cerrar socket

{
retorno (0);
}

importa aquí
para (i = 0; i <10; i ++)
{
getRequest [i] = SPI_Ethernet_24j600_getByte ();
}
getRequest [i] = 0;

{
retorno (0);
}

hecha

de transmisión
{

encabezado HTTP
texto tipo MIME





}
{

{
máscara de bits
}
}
hacer por defecto
{
encabezado HTTP
HTML MIME type
HTML primera parte
}

}
/ *
SPI_Ethernet_24j600_getByte ()
sucesivas a SPI_Ethernet_24j600_putByte ()
*
declaración
*
* /
unsigned int SPI_Ethernet_24j600_UserUDP ( unsigned char * remoteHost,
unsigned int remotePort, unsigned int destPort, unsigned int reqLength,
{
mi respuesta

dirección IP
dyna [3] = '.' ;
dyna [7] = '.' ;
dyna [11] = '.' ;

separador

dyna [21] = '[';
dyna [27] = ']';
dyna [28] = 0;


SPI_Ethernet_24j600_putBytes (dyna, 28);

while (reqLength--)
{
SPI_Ethernet_24j600_putByte (toupper
(SPI_Ethernet_24j600_getByte ()));
}

de la respuesta UDP
}
/ *
* Entrada principal
* /
void main ()
{
ANSEL = 0x0C; // se utilizarán los convertidores AN2 y
AN3
C2ON_bit = 0;
PORTA = 0;
TRISA = 0xff; // establece PORTA como entrada para ADC

digital
PORTB = 0;
botones
PORTD = 0;
/ *
* CS bit en RC1
* mi dirección MAC e IP
* duplex completo
* /
SPI1_Init ();
SPI_Ethernet_24j600_Init (myMacAddr, myIpAddr,
SPI_Ethernet_24j600_AUTO_NEGOTIATION);

{
/ *
* /
SPI_Ethernet_24j600_doPacket (); // procesar los
paquetes entrantes de Ethernet
/ *
* SPI_Ethernet_24j600_doPacket () debe llamarse tan a
menudo como sea posible
* /
}
}
SPI Graphic Lcd Library

mikroC PRO para PIC proporciona una biblioteca para operar Graphic Lcd 128x64
(con el controlador Samsung KS108 / KS107 comúnmente usado) a través de
la interfaz SPI .
Importante:

inicializar el módulo SPI antes de usar la biblioteca de gráficos SPI Lcd .
 Esta biblioteca está diseñada para funcionar con el pinout de la placa
adaptadora Serial Lcd / Glcd de mikroElektronika; consulte el esquema
en la parte inferior de esta página para obtener detalles.
 La familia de MCU PIC16 no admite trabajar con recursos externos.
Dependencias externas de SPI Lcd Library

La implementación de las rutinas de SPI Lcd Library se basa en las rutinas de Port
Expander Library.
Las dependencias externas son las mismas que las dependencias externas de
Port Expander Library .
Rutinas básicas:
 SPI_Glcd_Init
 SPI_Glcd_Set_Side
 SPI_Glcd_Set_Page
 SPI_Glcd_Set_X
 SPI_Glcd_Read_Data
 SPI_Glcd_Write_Data
 SPI_Glcd_Set_Ext_Buffer
Rutinas avanzadas:
 SPI_Glcd_Fill
 SPI_Glcd_Dot
 SPI_Glcd_Line
 SPI_Glcd_V_Line
 SPI_Glcd_H_Line
 SPI_Glcd_Rectangle
 SPI_Glcd_Rectangle_Round_Edges
 SPI_Glcd_Rectangle_Round_Edges_Fill
 SPI_Glcd_Box
 SPI_Glcd_Circle
 SPI_Glcd_Circle_Fill
 SPI_Glcd_Set_Font
 SPI_Glcd_Set_Font_Adv
 SPI_Glcd_Set_Ext_Font_Adv
 SPI_Glcd_Write_Char
 SPI_Glcd_Write_Char_Adv
 SPI_Glcd_Write_Text
 SPI_Glcd_Write_Text_Adv
 SPI_Glcd_Write_Const_Text_Adv
 SPI_Glcd_Image
 SPI_Glcd_Ext_Image
 SPI_Glcd_PartialImage
 SPI_Glcd_Ext_PartialImage
SPI_Glcd_Init
Prototipo void SPI_Glcd_Init ( char DeviceAddress);
Devoluciones Nada.
Descripción Inicializa el módulo Glcd a través de la interfaz SPI .

Parámetros:
 DeviceAddress: Dirección de hardware del
expansor SPI, vea el esquema al final de esta
página

Chip Select
reinicio


puertos
...
// Si Port Expander Library usa el módulo SPI:

SPI1_Init (); // Inicializar el módulo SPI usado
con PortExpander
SPI_Glcd_Init (0);
SPI_Glcd_Set_Side
Prototipo void SPI_Glcd_Set_Side ( char x_pos);
Devoluciones Nada.
Descripción Selecciona el lado Glcd. Consulte la hoja de datos de Glcd

para una explicación detallada.
Parámetros:
0..127
El parámetro x_posespecifica el lado de Glcd: los valores de
0 a 63 especifican el lado izquierdo, los valores de 64 a
127 especifican el lado derecho.

Requiere Glcd debe inicializarse para la comunicación SPI ,

consulte las rutinas SPI_Glcd_Init .
Ejemplo Las siguientes dos líneas son equivalentes, y ambas

seleccionan el lado izquierdo de Glcd:
SPI_Glcd_Set_Side (0);
SPI_Glcd_Set_Side (10);
SPI_Glcd_Set_Page
Prototipo vacío SPI_Glcd_Set_Page ( Char página);
Devoluciones Nada.
Descripción Selecciona la página de Glcd.

Parámetros:
 page:número de página. Valores válidos: 0..7


Ejemplo SPI_Glcd_Set_Page (5);
SPI_Glcd_Set_X
Prototipo void SPI_Glcd_Set_X ( char x_pos);
Devoluciones Nada.
Descripción Establece la posición del eje x en x_pospuntos desde el

borde izquierdo de Glcd dentro del lado seleccionado.
Parámetros:
0..63

Ejemplo SPI_Glcd_Set_X (25);
SPI_Glcd_Read_Data
Prototipo char SPI_Glcd_Read_Data ();
Devolucio Un byte de la memoria Glcd.

nes
Descripci Lee datos de la ubicación actual de la memoria de Glcd y se

ón mueve a la siguiente ubicación.

funciones SPI_Glcd_Set_Side , SPI_Glcd_Set_X y SPI_
Glcd_Set_Page .
Ejemplo Char datos;

...
datos = SPI_Glcd_Read_Data ();
SPI_Glcd_Write_Data
Prototipo void SPI_Glcd_Write_Data ( char Ddata);
Devolucio Nada.
nes
Descripci Escribe un byte a la ubicación actual en la memoria Glcd y se

ón mueve a la siguiente ubicación.
Parámetros:
 Ddata: datos a escribir

Glcd_Set_Page .

...
SPI_Glcd_Write_Data (data_);
SPI_Glcd_Set_Ext_Buffer
Prototipo anulará SPI_Glcd_Set_Ext_Buffer (char * (*
getExtDataPtr) ( unsigned long offset, largo sin
signo recuento, sin firmar larga * num));
Devolucio Nada.
nes
Descripci La función establece el puntero a la función de usuario que

ón manipula el recurso externo.
Parámetros:
 num - variable para mantener el número devuelto
ob byte (menor o igual que el número de bytes
conectados).
Requiere Glcd debe inicializarse para la comunicación SPI , consulte

la rutina SPI_Glcd_Init .
Glcd_Set_Page .

unsigned int pos;
start_sector = Mmc_Get_File_Write_Sector () + offset

/ 512;
} else
}
* num = 512-pos;
}
más
* num = cuenta;

}
SPI_Glcd_Set_Ext_Buffer (ReadExternalBuffer);
SPI_Glcd_Fill
Prototipo anular SPI_Glcd_Fill ( Char patrón);
Devoluciones Nada.
Descripción Rellena la memoria Glcd con un byte pattern.

Parámetros:
 pattern: byte para llenar la memoria Glcd con
Para borrar la pantalla de Glcd, use SPI_Glcd_Fill(0).
Para llenar la pantalla completamente,
use SPI_Glcd_Fill(0xFF).

Ejemplo // Pantalla clara

SPI_Glcd_Fill (0);
SPI_Glcd_Dot
Prototipo void SPI_Glcd_Dot
( char x_pos, char y_pos, char color);
Devoluciones Nada.
Descripción Dibuja un punto en Glcd en las coordenadas

( x_pos, y_pos).
Parámetros:
 x_pos:posición x Valores válidos: 0..127
 y_pos:posición y Valores válidos: 0..63
El parámetro colordetermina el estado del punto: 0 borra
el punto, 1 pone un punto y 2 invierte el estado del punto.
Nota: Para la explicación del diseño de los lados, x e

y laterales, vea el esquema al final de esta página.

Ejemplo // Invertir el punto en la esquina superior

izquierda
SPI_Glcd_Dot (0, 0, 2);
SPI_Glcd_Line
Prototipo void SPI_Glcd_Line
( int x_start, int y_start, int x_end, inty_end, cha
r color);
Devolucion Nada.
es
Descripció Dibuja una línea en Glcd.

n Parámetros:
 x_end:Coordenada x del final de la línea. Valores
válidos: 0..127
 y_end:Coordenada y del final de la línea. Valores
válidos: 0..63
El parámetro colordetermina el color de la línea: 0 blanco, 1

Ejemplo // Dibuja una línea entre los puntos (0,0) y (20,30)

SPI_Glcd_Line (0, 0, 20, 30, 1);
SPI_Glcd_V_Line
Prototipo void SPI_Glcd_V_Line
( char y_start, char y_end, char x_pos, charcolor)
;
Devolucione Nada.
s
Descripción Dibuja una línea vertical en Glcd.

Parámetros:
 y_end:Coordenada y del final de la
 x_pos:coordenada x de linea vertical. Valores
válidos: 0..127

y (10,25)
SPI_Glcd_V_Line (5, 25, 10, 1);
SPI_Glcd_H_Line
Prototipo void SPI_Glcd_H_Line
( char x_start, char x_end, char y_pos, char color
);
Devolucione Nada.
s
Descripción Dibuja una línea horizontal en Glcd.

Parámetros:
 x_end:Coordenada x del final de la
 y_pos:y coordenada de linea horizontal. Valores
válidos: 0..63


(10,20) y (50,20)
SPI_Glcd_H_Line (10, 50, 20, 1);
SPI_Glcd_Rectangle
Prototi void SPI_Glcd_Rectangle
po ( char x_upper_left, char y_upper_left, charx_bottom_ri
ght, char y_bottom_right, char color);
Devolu Nada.
ciones
Descrip Dibuja un rectángulo en Glcd.

ción Parámetros:
 x_upper_left:Coordenada x de la esquina superior
izquierda del rectángulo. Valores válidos: 0..127
 y_upper_left:Coordenada y de la esquina superior
izquierda del rectángulo. Valores válidos: 0..63
 x_bottom_right:Coordenada x de la esquina inferior
derecha del rectángulo. Valores válidos: 0..127
 y_bottom_right:Coordenada y de la esquina inferior
derecha del rectángulo. Valores válidos: 0..63
El parámetro colordetermina el color del borde del rectángulo: 0
Requier Glcd debe inicializarse para la comunicación SPI ,
e consulte las rutinas SPI_Glcd_Init .
Ejempl // Dibuja un rectángulo entre los puntos (5,5) y (40,40)

o SPI_Glcd_Rectangle (5, 5, 40, 40, 1);
SPI_Glcd_Rectangle_Round_Edges
Prototipo void SPI_Glcd_Rectangle_Round_Edges ( sin signo
corto y_bottom_right, sin
signo redondeado corto redondeado, sin signo
de color corto );
Devoluciones Nada.

Parámetros:
válidos: 0..127
válidos: 0..63
0..127
0..63
Requiere Glcd debe inicializarse, consulte la rutina SPI_Glcd_Init .
Ejemplo // Dibuje un rectángulo de borde redondeado entre

los puntos (5,5) y (40,40) con el radio de 12
SPI_Glcd_Rectangle_Round_Edges (5, 5, 40, 40, 12,
1);
SPI_Glcd_Rectangle_Round_Edges_Fill
Prototipo void SPI_Glcd_Rectangle_Round_Edges_Fill ( sin
signo corto x_upper_left, sin signo
corto y_bottom_right, sin signo
corto red_radio, sin signo de color corto );
Devoluciones Nada.
Descripción Dibuja un borde de borde redondeado relleno en Glcd con

color.
Parámetros:
válidos: 0..127
válidos: 0..63
0..127
0..63
Requiere Glcd debe inicializarse, consulte la rutina SPI_Glcd_Init .
Ejemplo // Dibuja un rectángulo de borde redondeado relleno

entre los puntos (5,5) y (40,40) con el radio de 12
SPI_Glcd_Rectangle_Round_Edges_Fill (5, 5, 40, 40,
12, 1);
SPI_Glcd_Box
Prototi void SPI_Glcd_Box
po ( char x_upper_left, char y_upper_left, charx_bottom_ri
ght, char y_bottom_right, char color);
Devolu Nada.
ciones
Descrip Dibuja una caja en Glcd.

ción Parámetros:
 x_upper_left:Coordenada x de la esquina superior
izquierda del cuadro. Valores válidos: 0..127
 y_upper_left:Coordenada y de la esquina superior
izquierda del cuadro. Valores válidos: 0..63
 x_bottom_right:Coordenada x de la esquina inferior
derecha del cuadro. Valores válidos: 0..127
 y_bottom_right:Coordenada y de la esquina inferior
derecha del cuadro. Valores válidos: 0..63
El parámetro colordetermina el color del relleno del cuadro: 0
Requier Glcd debe inicializarse para la comunicación SPI ,
e consulte las rutinas SPI_Glcd_Init .
Ejempl // Dibuja un cuadro entre los puntos (5,15) y (20,40)

o SPI_Glcd_Box (5, 15, 20, 40, 1);
SPI_Glcd_Circle
Prototipo void SPI_Glcd_Circle
( int x_center, int y_center, int radio, charcolor
);
Devolucione Nada.
s

Parámetros:


10
SPI_Glcd_Circle (50, 50, 10, 1);
SPI_Glcd_Circle_FIll
Prototipo void SPI_Glcd_Circle_Fill
( int x_center, int y_center, int radius, char col
or);
Devolucione Nada.
s

Parámetros:
El parámetro colordetermina el color del círculo: 0 blanco,
la rutina SPI_Glcd_Init.

10
SPI_Glcd_Circle_Fill (50, 50, 10, 1);
SPI_Glcd_Set_Font
Prototipo void SPI_Glcd_Set_Font ( const code char *
activeFont, char aFontWidth, charaFontHeight, unsig
ned int aFontOffs);
Devolucione Nada.
s

las rutinas SPI_Glcd_Write_Char y SPI_Glcd_Write_
Text .
Parámetros:
 activeFont:fuente a configurar. Necesita ser
 aFontWidth: ancho de los caracteres de la
fuente en puntos.
 aFontHeight: Altura de los caracteres
tipográficos en puntos.
 aFontOffs:número que representa la diferencia
entre el conjunto de caracteres mikroC PRO for
PIC y el conjunto ASCII regular (por ejemplo, si
'A' es 65 en el carácter ASCII, y 'A' es 45 en el
conjunto de caracteres mikroC PRO, aFontOffs
es 20). Las fuentes de demostración
suministradas con la biblioteca tienen un
desplazamiento de 32, lo que significa que
comienzan con espacio.
El usuario puede usar las fuentes proporcionadas en el
archivo __Lib_GLCDFontsubicado en la carpeta Usos o crear
sus propias fuentes.
Lista de fuentes soportadas:
 Font_Glcd_5x7
 Font_Glcd_Character8x7
Por el bien de la compatibilidad con versiones anteriores,
estas fuentes también son compatibles:
 System3x5(equivalente a Font_Glcd_System3x5)
 FontSystem5x7_v2(equivalente
a Font_Glcd_System5x7)
 font5x7(equivalente a Font_Glcd_5x7)
 Character8x7(equivalente
a Font_Glcd_Character8x7)
Ejemplo // Use la fuente 5x7 personalizada "myfont" que

comienza con el espacio (32):
SPI_Glcd_Set_Font (myfont, 5, 7, 32);
SPI_Glcd_Set_Font_Adv
Prototipo void SPI_Glcd_Set_Font_Adv ( const char *
char font_color, char font_orientation);
Descripci Establece la fuente que se utilizará con

ón las rutinas SPI_Glcd_Write_Char_Adv y SPI_Glcd_Writ
e_Text_Adv . La fuente se encuentra en un recurso externo.
Parámetr  activeFont:fuente a configurar. Necesita ser

os formateado como una matriz de caracteres.
 font_orientation: Establece la orientación de la
fuente.
Devolucio Nada.
nes

Ejemplo Glcd_Set_Font_Adv (& myfont, 0, 0);
Notas Ninguna.
SPI_Glcd_Set_Ext_Font_Adv
Prototipo void SPI_Glcd_Set_Ext_Font_Adv ( sin signo
long activeFont, sin signo corto aFontWidth, sin
signo corto aFontHeight, unsigned intaFontOffs);

ón las rutinas SPI_Glcd_Write_Char_Adv y SPI_Glcd_Writ
e_Text_Adv . La fuente se encuentra en un recurso externo.
Parámetr  activeFont:fuente a configurar. Este parámetro

os representa la dirección en el recurso externo
desde donde comienzan los datos de la fuente.
fuente.
Devolucio Nada.
nes

Ejemplo SPI_Glcd_Set_Ext_Font_Adv (173296, 5, 7, 32);
Notas Ninguna.
SPI_Glcd_Write_Char
Prototipo void SPI_Glcd_Write_Char
( char chr1, char x_pos, char page_num, char color
);
Devolucione Nada.
s
Descripción Imprime carácter en Glcd.

Parámetros:
 chr1: personaje para ser escrito
 x_pos:Posición inicial del personaje en el eje
x. Valores válidos: 0 .. (127-FontWidth)
 page_num:el número de la página en la que se
escribirá el carácter. Valores válidos: 0..7
El parámetro colordetermina el color del carácter: 0


Utilice SPI_Glcd_Set_Font para especificar la fuente
para la visualización; si no se especifica ninguna
fuente, Font_Glcd_System5x7se
utilizará la fuente predeterminada que se suministra con la
biblioteca.
Ejemplo // Escriba el carácter 'C' en la posición 10 dentro

de la página 2:
SPI_Glcd_Write_Char ('C', 10, 2, 1);
SPI_Glcd_Write_Char_Adv
Prototipo void SPI_Glcd_Write_Char_Adv ( unsigned
int c, unsigned int x, unsigned int y);
Devoluciones Nada.
Descripción Escribe un char en el glcd en las coordenadas (x, y).


Ejemplo SPI_Glcd_Write_Char_Adv ('A', 22,23);
SPI_Glcd_Write_Text
Prototipo void SPI_Glcd_Write_Text
( texto char [], char x_pos, charpage_num, char col
or);
Devolucione Nada.
s
Descripción Imprime texto en Glcd.

Parámetros:
 x_pos: Posición inicial del texto en el eje x.
 page_num:El número de la página en la que se
escribirá el texto. Valores válidos: 0..7
El parámetro colordetermina el color del texto: 0 blanco, 1


Utilice SPI_Glcd_Set_Font para especificar la fuente para
la visualización; si no se especifica ninguna
fuente, Font_Glcd_System5x7se
utilizará la fuente predeterminada que se suministra con la
biblioteca.
Ejemplo // Escribir texto "¡Hola mundo!" en la posición 10

dentro de la página 2:
SPI_Glcd_Write_Text ("¡Hola mundo!", 10, 2, 1);
SPI_Glcd_Write_Text_Adv
Prototipo void SPI_Glcd_Write_Text_Adv
( texto sin signo *, int sin signo x, int y sin
signo );
Devoluciones Nada.
Descripción Escribe texto en el glcd en coordenadas (x, y).

Parámetros:

Ejemplo SPI_Glcd_Write_Text_Adv ("GLCD LIBRARY DEMO,

WELCOME!", 0, 0);
SPI_Glcd_Write_Const_Text_Adv
Prototipo void SPI_Glcd_Write_Const_Text_Adv ( const far
char * text, unsigned int x, unsigned int y);
Devoluciones Nada.

Parámetros:

Ejemplo const char ctext [] = "mikroElektronika";

...
SPI_Glcd_Write_Const_Text_Adv (ctext, 0, 0);
SPI_Glcd_Image
Prototipo void SPI_Glcd_Image ( const code char * image);
Devoluciones Nada.

Parámetros:

Ejemplo // Dibujar imagen mi_imagen en Glcd

SPI_Glcd_Image (mi_imagen);
SPI_Glcd_Ext_Image
Prototipo void SPI_Glcd_Ext_Image ( imagen larga sin
firmar );
Descripción Muestra un mapa de bits de un recurso externo en una

dirección deseada.
Parámetros  image:Imagen a mostrar. Este parámetro

imagen.
Devoluciones Nada.

Ejemplo SPI_Glcd_Ext_Image (153608);
Notas Utilice el Editor de mapas de bits de Glcd integrado de

mikroC PRO for AVR, Herramientas > Editor de
mapas de bits de Glcd , para convertir la imagen en
una matriz constante adecuada para mostrar en Glcd.
SPI_Glcd_PartialImage
Prototipo void SPI_Glcd_PartialImage ( sin signo
int picture_width, sin signo
imagen);
Devoluciones Nada.

deseada.
Parámetros:


SPI_Glcd_PartialImage (10, 12, 10, 15, 16, 32,
imagen);
SPI_Glcd_Ext_PartialImage
Prototipo void SPI_Glcd_Ext_PartialImage ( sin signo


imagen.
Devoluciones Nada.

Ejemplo SPI_Glcd_Ext_PartialImage (10, 12, 10, 15, 16, 32,
0);
Notas Utilice el Editor de mapas de bits de Glcd integrado de

mikroC PRO for AVR, Herramientas > Editor de
mapas de bits de Glcd , para convertir la imagen en
una matriz constante adecuada para mostrar en Glcd.
El ejemplo muestra cómo comunicarse con KS0108 Glcd a través del módulo SPI,
utilizando el convertidor serie a paralelo MCP23S17.
const code char truck_bmp [1024];

void Delay2s () { // 2 segundos de retraso de la

función
Delay_ms (2000);
}
void main () {
char counter;
char * someText;
#define COMPLETE_EXAMPLE
digitales
ANSELH = 0;
C2ON_bit = 0;

SPI1_Init (); // Inicializar el
módulo SPI usado con PortExpander
// // Si Port Expander Library utiliza el módulo SPI2

SPI_Glcd_Init (0); // Inicializar Glcd a

través de SPI
SPI_Glcd_Fill (0x00); // Borrar Glcd
mientras (1) {
SPI_Glcd_Image (truck_bmp); // dibujar imagen
Delay2s (); Delay2s ();
#terminara si
SPI_Glcd_Fill (0x00); // Borrar Glcd
Delay2s;
SPI_Glcd_Box (62,40,124,56,1); // Cuadro de

dibujo SPI_Glcd_Rectangle (5,5,84,35,1); // Dibuja el
rectángulo
SPI_Glcd_Line (0, 63, 127, 0,1); // Dibujar linea
Delay2s ();
para (contador = 5; contador <60; contador + = 5) { // Dibuja una

línea horizontal y vertical
Delay_ms (250);
SPI_Glcd_V_Line (2, 54, contador, 1);
SPI_Glcd_H_Line (2, 120, contador, 1);
}
Delay2s ();
SPI_Glcd_Fill (0x00); // Borrar
Glcd
SPI_Glcd_Set_Font (Font_Glcd_Character8x7, 8, 8, 32); // Elija la
fuente, vea __Lib_GLCDFonts.c en la carpeta Usos
SPI_Glcd_Write_Text ("mikroE", 5, 7, 2); // escribir
cadena
#terminara si
para (contador = 1; contador <= 10; contador ++) //

Dibujar círculos
SPI_Glcd_Circle (63,32, 3 * contador, 1);
Delay2s ();
SPI_Glcd_Box (12,20, 70,63, 2); // dibujar
caja
Delay2s ();
SPI_Glcd_Fill (0xFF); // Llene

Glcd
SPI_Glcd_Set_Font (Font_Glcd_Character8x7, 8, 7, 32); // Cambiar
fuente
SPI_Glcd_Write_Text (someText, 5, 1, 2); // escribir
cadena
Delay2s ();
SPI_Glcd_Set_Font (Font_Glcd_System3x5, 3, 5, 32); // Cambiar

fuente
someText = "SÓLO CAPITALS 3X5";
cadena
Delay2s ();
SPI_Glcd_Set_Font (Font_Glcd_System5x7, 5, 7, 32); // Cambiar

fuente
cadena
Delay2s ();
SPI_Glcd_Set_Font (Font_Glcd_5x7, 5, 7, 32); // Cambiar

fuente
someText = "5x7 Font (v2)";
cadena
Delay2s ();
#terminara si
}
}
Conexión HW
Conexión SPI Glcd HW
Biblioteca SPI Lcd

El mikroC PRO para PIC proporciona una biblioteca para la comunicación
con Lcd (con controladores compatibles con HD44780) en modo de 4 bits a través
de la interfaz SPI .
Para crear un conjunto personalizado de caracteres Lcd , use la Herramienta
Importante:

inicializar el módulo SPI antes de utilizar la biblioteca de SPI Lcd .
adaptadora de Lcd serie de mikroElektronika. Vea el esquema en la
parte inferior de esta página para más detalles.

Expander Library.
 SPI_Lcd_Config
 SPI_Lcd_Out
 SPI_Lcd_Out_Cp
 SPI_Lcd_Chr
 SPI_Lcd_Chr_Cp
 SPI_Lcd_Cmd
SPI_Lcd_Config
Prototipo void SPI_Lcd_Config ( char DeviceAddress);
Devoluciones Nada.
Descripción Inicializa el módulo Lcd a través de la interfaz SPI .

Parámetros:
página

Chip Select
reinicio

puertos
void main () {

SPI1_Init (); //
Inicializar el módulo SPI utilizado con PortExpander
SPI_Lcd_Config (0); //
inicializar Lcd sobre la interfaz SPI
SPI_Lcd_Out
Prototipo anulará SPI_Lcd_Out
( Char fila, carbón columna, Char * texto);
Devoluciones Nada.
Descripción Imprime texto en el Lcd a partir de la posición

especificada. Tanto las variables de cadena como los
literales se pueden pasar como texto.
Parámetros:
Requiere Lcd debe inicializarse para la comunicación SPI ,

consulte las rutinas SPI_Lcd_Config .

fila 1, columna 3:
SPI_Lcd_Out (1, 3, "Hello!");
SPI_Lcd_Out_Cp
Prototipo void SPI_Lcd_Out_CP ( char * text);
Devoluciones Nada.
Descripción Imprime texto en el Lcd en la posición actual del

Parámetros:

cursor:
SPI_Lcd_Out_CP ("Here!");
SPI_Lcd_Chr
Prototipo void SPI_Lcd_Chr
( char Row, char Column, char Out_Char);
Devoluciones Nada.

especificada. Tanto las variables como los literales se
pueden pasar como carácter.
Parámetros:
 Row: número de fila de posición de escritura
 Column: número de columna de posición de
escritura
 Out_Char: personaje para ser escrito

Ejemplo // Escriba el carácter "i" en la fila 2, columna 3:

SPI_Lcd_Chr (2, 3, 'i');
SPI_Lcd_Chr_Cp
Prototipo void SPI_Lcd_Chr_CP ( char Out_Char);
Devoluciones Nada.

cursor. Tanto las variables como los literales se pueden
pasar como carácter.
Parámetros:
 Out_Char: personaje para ser escrito

Ejemplo // Escriba el carácter "e" en la posición actual del

cursor:
SPI_Lcd_Chr_Cp ('e');
SPI_Lcd_Cmd
Prototipo void SPI_Lcd_Cmd ( char out_char);
Devoluciones Nada.
Parámetros:

función, consulte Comandos disponibles de Lcd SPI .

Ejemplo // Borrar la pantalla LCD:

SPI_Lcd_Cmd (_LCD_CLEAR);
Comandos disponibles de SPI Lcd

Comando SPI Lcd Propósito




pantalla RAM

de la pantalla RAM
Este ejemplo muestra cómo comunicar Lcd a través del módulo SPI, utilizando el
convertidor serie a paralelo MCP23S17.
char * text = "mikroElektronika";

void main () {

digitales
ANSELH = 0;
C2ON_bit = 0;


SPI_Lcd_Config (0); // Inicializar Lcd sobre la

interfaz SPI
SPI_Lcd_Cmd (_LCD_CLEAR); // Borrar pantalla
SPI_Lcd_Cmd (_LCD_CURSOR_OFF); // Apague el cursor
SPI_Lcd_Out (1,6, "mikroE"); // Imprimir texto en Lcd, 1ª
fila, 6ª columna
SPI_Lcd_Chr_CP ('!'); // Adjuntar '!'
SPI_Lcd_Out (2,1, texto); // Imprimir texto a Lcd, 2ª
fila, 1ª columna
// SPI_Lcd_Out (3,1, "mikroE"); // Para Lcd con más de dos filas

// SPI_Lcd_Out (4,15, "mikroE"); // Para Lcd con más de dos filas.
}
Conexión HW
Conexión SPI Lcd HW
Biblioteca SPI Lcd 8 (interfaz de 8 bits)
El mikroC PRO para PIC proporciona una biblioteca para la comunicación
con Lcd (con controladores compatibles con HD44780) en modo de 8 bits a través
de la interfaz SPI .
Para crear un conjunto personalizado de caracteres Lcd, use la Herramienta
Importante:

inicializar el módulo SPI antes de usar la biblioteca SPI Lcd 8.
adaptadora Serial Lcd / Glcd de mikroElektronika. Vea el esquema en la
parte inferior de esta página para más detalles.

Expander Library.
 SPI_Lcd8_Config
 SPI_Lcd8_Out
 SPI_Lcd8_Out_Cp
 SPI_Lcd8_Chr
 SPI_Lcd8_Chr_Cp
 SPI_Lcd8_Cmd
SPI_Lcd8_Config
Prototipo void SPI_Lcd8_Config ( char DeviceAddress);
Devoluciones Nada.
Descripción Inicializa el módulo Lcd a través de la interfaz SPI .

Parámetros:
página

Chip Select
reinicio


puertos
...
SPI1_Init (); //
Inicializar el módulo SPI utilizado con PortExpander
SPI_Lcd8_Config (0); //
intialize Lcd en modo de 8 bits a través de SPI
SPI_Lcd8_Out
Prototipo void SPI_Lcd8_Out ( fila corta sin signo ,
columna corta sin signo , texto char *);
Devoluciones Nada.
Descripción Imprime texto en Lcd desde la posición especificada. Tanto

las variables de cadena como los literales se pueden pasar
como texto.
Parámetros:
Requiere Lcd debe inicializarse para la comunicación SPI , consulte

la rutina SPI_Lcd8_Config .

fila 1, columna 3:
SPI_Lcd8_Out (1, 3, "Hello!");
SPI_Lcd8_Out_Cp
Prototipo void SPI_Lcd8_Out_CP ( char * text);
Devoluciones Nada.
Descripción Imprime texto en Lcd en la posición actual del

Parámetros:


cursor:
SPI_Lcd8_Out_Cp ("Here!");
SPI_Lcd8_Chr
Prototipo void SPI_Lcd8_Chr ( fila corta sin signo ,
columna corta sin signo, char out_char);
Devoluciones Nada.

especificada. Tanto las variables como los literales se
pueden pasar como carácter.
Parámetros:
 row: número de fila de posición de escritura
 column: número de columna de posición de
escritura

Ejemplo // Escribe el carácter "i" en la fila 2, columna 3:

SPI_Lcd8_Chr (2, 3, 'i');
SPI_Lcd8_Chr_Cp
Prototipo void SPI_Lcd8_Chr_CP ( char out_char);
Devoluciones Nada.

cursor. Tanto las variables como los literales se pueden
pasar como carácter.
Parámetros:

Ejemplo Imprima “e” en la posición actual del cursor:

// Escriba el carácter "e" en la posición actual del
cursor:
SPI_Lcd8_Chr_Cp ('e');
SPI_Lcd8_Cmd
Prototipo void SPI_Lcd8_Cmd ( char out_char);
Devoluciones Nada.

Parámetros:
función, consulte Comandos disponibles SPI Lcd8 .

Ejemplo // Borrar pantalla lcd:

SPI_Lcd8_Cmd (_LCD_CLEAR);
Comandos SPI Lcd8 disponibles

Comando SPI Lcd8 Propósito




pantalla RAM

de la pantalla RAM
Este ejemplo muestra cómo comunicar Lcd en modo de 8 bits a través del módulo
SPI, utilizando el convertidor en serie a paralelo MCP23S17.
char * text = "mikroElektronika";

void main () {

digitales
ANSELH = 0;
C2ON_bit = 0;


SPI_Lcd8_Config (0); // Inicializar Lcd sobre la

interfaz SPI
SPI_Lcd8_Cmd (_LCD_CLEAR); // Borrar pantalla
SPI_Lcd8_Cmd (_LCD_CURSOR_OFF); // Apague el cursor
SPI_Lcd8_Out (1,6, "mikroE"); // Imprimir texto en Lcd,
primera fila, sexta columna
SPI_Lcd8_Chr_CP ('!'); // Adjuntar '!'
SPI_Lcd8_Out (2,1, texto); // Imprimir texto a Lcd, 2ª
fila, 1ª columna
// SPI_Lcd8_Out (3,1, "mikroE"); // Para Lcd con más de dos filas

// SPI_Lcd8_Out (4,15, "mikroE"); // Para Lcd con más de dos filas
}
Conexión HW
Conexión SPI Lcd8 HW
SPI T6963C Graphic Lcd Library
El mikroC PRO para PIC proporciona una biblioteca para trabajar con Glcds basado
en el controlador TOSHIBA T6963C a través de la interfaz SPI . El Toshiba T6963C
es un controlador Lcd muy popular para el uso en pequeños módulos gráficos. Es
capaz de controlar pantallas con una resolución de hasta 240x128. Debido a su
baja potencia y pequeño perfil, es más adecuado para aplicaciones móviles como
PDA, reproductores de MP3 o equipos de medición móviles. Aunque este
controlador es pequeño, tiene la capacidad de mostrar y combinar texto y gráficos,
y administra todas las señales de interfaz a los controladores de fila y columna de
las pantallas.
Importante:
 La biblioteca utiliza el módulo SPI para la comunicación.
 El usuario debe inicializar el módulo SPI antes de usar la biblioteca SPI
T6963C Glcd.
 Esta biblioteca está diseñada para trabajar con las placas adaptadoras
Serial Glcd 240x128 y 240x64 de mikroElektronika; consulte el
esquema en la parte inferior de esta página para obtener más
información.
 Para utilizar las constantes localizadas en __Lib_SPIT6963C_Const.hel
archivo, el usuario debe incluir el archivo de origen: #include
"__SPIT6963C.h".
 La familia de MCU PIC16 no admite trabajar con recursos externos.
Algunas tarjetas adaptadoras de mikroElektronika tienen un pinout diferente de las
hojas de datos T6369C. Las relaciones apropiadas entre estas etiquetas se dan en
la siguiente tabla:
Placa adaptadora Hoja de datos de T6369C
RS DISCOS COMPACTOS
R/W / RD
mi / WR
Dependencias externas de SPI T6963C Graphic Lcd Library

La implementación de SPI T6963C Graphic Lcd Library se basa en las rutinas de
Port Expander Library.
 SPI_T6963C_Config
 SPI_T6963C_writeData
 SPI_T6963C_writeCommand
 SPI_T6963C_setPtr
 SPI_T6963C_Set_Ext_Buffer
 SPI_T6963C_waitReady
 SPI_T6963C_fill
 SPI_T6963C_dot
 SPI_T6963C_Set_Font_Adv
 SPI_T6963C_Set_Font_Ext_Adv
 SPI_T6963C_write_char
 SPI_T6963C_Write_Char_Adv
 SPI_T6963C_write_text
 SPI_T6963C_Write_Text_Adv
 SPI_T6963C_Write_Const_Text_Adv
 SPI_T6963C_line
 SPI_T6963C_rectangle
 SPI_T6963C_rectangle_round_edges
 SPI_T6963C_rectangle_round_edges_fill
 SPI_T6963C_box
 SPI_T6963C_circle
 SPI_T6963C_circle_fill
 SPI_T6963C_image
 SPI_T6963C_Ext_Image
 SPI_T6963C_PartialImage
 SPI_T6963C_Ext_PartialImage
 SPI_T6963C_sprite
 SPI_T6963C_set_cursor
 SPI_T6963C_clearBit
 SPI_T6963C_setBit
 SPI_T6963C_negBit
Las siguientes rutinas de biblioteca de bajo nivel se implementan como
macros. Estas macros se pueden encontrar en el __SPIT6963C.harchivo de
encabezado que se encuentra en las carpetas de proyectos de ejemplo SPI T6963C.
 SPI_T6963C_displayGrPanel
 SPI_T6963C_displayTxtPanel
 SPI_T6963C_setGrPanel
 SPI_T6963C_setTxtPanel
 SPI_T6963C_panelFill
 SPI_T6963C_grFill
 SPI_T6963C_txtFill
 SPI_T6963C_cursor_height
 SPI_T6963C_graphics
 SPI_T6963C_text
 SPI_T6963C_cursor
 SPI_T6963C_cursor_blink
SPI_T6963C_Config
Prototipo void SPI_T6963C_Config ( ancho int
sin signo , alto char sinsigno, fntW char
sin signo, DeviceAddress char , char wr sin
signo, char rd sin
signo , char cd sin signo , char rst sin signo );
Devoluciones Nada.
Descripción Inicializa T6963C Graphic Lcd controller.

Parámetros:
 width: ancho del panel glcd
 height: altura del panel glcd
 fntW: ancho de fuente
página
 wr: pin de señal de escritura en el puerto de
control de Glcd
 rd: leer el pin de señal en el puerto de control
de Glcd
 cd: Comando / señal de señal de datos en el
puerto de control de Glcd
 rst: pin de señal de reinicio en el puerto de
control de Glcd
Organización de la RAM de visualización:
La biblioteca divide la RAM en los paneles: un panel
completo es un panel de gráficos seguido de un panel de
texto (vea el esquema a continuación).
esquemático:
+ --------------------- + / \
+ PANEL GRÁFICO # 0 + |
+ + |
+ + |
+ + |
+ --------------------- + | PANEL 0
+ PANEL DE TEXTO # 0 + |
+ + \ /
+ --------------------- + / \
+ PANEL GRÁFICO # 1 + |
+ + |
+ + |
+ + |
+ --------------------- + | PANEL 1
+ PANEL DE TEXTO # 1 + |
+ + |
+ --------------------- + \ /

Chip Select
reinicio


puertos
...
// Inicializar módulo SPI

SPI1_Init ();
SPI_T6963C_Config (240, 64, 8, 0, 0, 1, 3, 4);
SPI_T6963C_writeData
Prototipo void SPI_T6963C_writeData (ddata de
caracteres sin signo);
Devoluciones Nada.
Descripción Escribe datos en el controlador T6963C a través de

la interfaz SPI .
Parámetros:
 Ddata: datos a escribir
Requiere El módulo Toshiba Glcd necesita ser inicializado. Ver

la rutina SPI_T6963C_Config .
Ejemplo SPI_T6963C_writeData (AddrL);
SPI_T6963C_writeCommand
Prototipo void SPI_T6963C_writeCommand (ddata de
caracteres sin signo);
Devoluciones Nada.
Descripción Escribe el comando en el controlador T6963C a través de

la interfaz SPI .
Parámetros:
 Ddata: orden de ser escrito

Ejemplo SPI_T6963C_writeCommand
(SPI_T6963C_CURSOR_POINTER_SET);
SPI_T6963C_setPtr
Prototipo void SPI_T6963C_setPtr ( unsigned int p, unsigned
char c);
Devoluciones Nada.
Descripción Establece el puntero de memoria p para el comando c.

Parámetros:
 p: dirección donde debe escribirse el comando
 c: orden de ser escrito
Requiere Es necesario inicializar el módulo SToshiba Glcd. Ver

Ejemplo SPI_T6963C_setPtr (SPI_T6963C_grHomeAddr + start,

SPI_T6963C_ADDRESS_POINTER_SET);
SPI_T6963C_Set_Ext_Buffer
Prototipo void SPI_T6963C_Set_Ext_Buffer (char * (*
getExtDataPtr) ( desplazamiento largo sin signo ,
cuenta int sin signo , int * num sin signo ));
Devoluciones Nada.

Parámetros:
devuelto de bytes (menor o igual al número de
bytes adquiridos).


unsigned int pos;
offset / 512;
} else
}
* num = 512-pos;
}
más
* num = cuenta;

}
SPI_T6963C_Set_Ext_Buffer (ReadExternalBuffer);
SPI_T6963C_waitReady
Prototipo void SPI_T6963C_waitReady ( void );
Devoluciones Nada.
Descripción Agrupa el byte de estado y realiza un bucle hasta que el

módulo Toshiba Glcd esté listo.

Ejemplo SPI_T6963C_waitReady ();
SPI_T6963C_fill
Prototipo void SPI_T6963C_fill ( unsigned char v, unsigned
int start, unsigned int len);
Devoluciones Nada.
Descripción Rellena el bloque de memoria del controlador con un byte

dado.
Parámetros:
 v: byte para ser escrito
 start: dirección de inicio del bloque de
memoria
 len: Longitud del bloque de memoria en bytes.

Ejemplo SPI_T6963C_fill (0x33,0x00FF, 0x000F);
SPI_T6963C_dot
Prototipo void SPI_T6963C_dot ( int x, int y, unsigned
char color);
Devoluciones Nada.
Descripción Dibuja un punto en el panel gráfico actual de Glcd en las

coordenadas (x, y).
Parámetros:
 x: posición del punto en el eje x
 y: posición del punto en el eje y
SPI_T6963C_BLACK, SPI_T6963C_WHITE y
SPI_T6963C_INVERT.

Ejemplo SPI_T6963C_dot (x0, y0, SPI_T6963C_WHITE);
SPI_T6963C_Set_Font_Adv
Prototipo void SPI_T6963C_Set_Font_Adv ( const far char *

ón las rutinas SPI_T6963C_Write_Char_Adv y SPI_T6963
C_Write_Text_Adv .
Parámetr  activeFont:fuente a configurar. Necesita ser

os formateado como una matriz de caracteres.
fuente.
Devolucio Nada.
nes

Ejemplo SPI_T6963C_Set_Font_Adv (& myfont, 1, 0);
Notas Ninguna.
SPI_T6963C_Set_Ext_Font_Adv
Prototipo void SPI_T6963C_Set_Ext_Font_Adv ( sin signo
long activeFont, unsigned

ón las rutinas SPI_T6963C_Write_Char_Adv y SPI_T6963
C_Write_Text_Adv . La fuente se encuentra en un recurso
externo.
Parámetr  activeFont:fuente a configurar. Este parámetro

os representa la dirección en el recurso externo desde
donde comienzan los datos de la fuente.
fuente.
Devoluci Nada.
ones
Ejemplo SPI_T6963C_Set_Ext_Font_Adv (173296, 0, 0);
Notas Ninguna.
SPI_T6963C_write_char
Prototi void SPI_T6963C_write_char ( unsigned char c, unsigned
po char x, unsigned char y, unsigned char mode);
Devolu Nada.
ciones
Descri Escribe un carácter en el panel de texto actual de Glcd en las

pción coordenadas (x, y).
Parámetros:
 c: char para ser escrito
 x: posición char en el eje x
 y: posición char en el eje y
 mode:parámetro de modo Los valores
válidos: SPI_T6963C_ROM_MODE_OR, SPI_T6963C_ROM_MO
DE_XOR, SPI_T6963C_ROM_MODE_ANDySPI_T6963C_ROM_MO
DE_TEXT
Explicación de los parámetros de modo:
 SPI_T6963C_ROM_MODE_ORModo: En el modo OR, se
pueden mostrar texto y gráficos y los datos están
lógicamente "OR-ed". Esta es la forma más común de
combinar texto y gráficos, por ejemplo, etiquetas en
botones.
 SPI_T6963C_ROM_MODE_XORModo: En este modo, los
datos de texto y gráficos se combinan a través del "OR
exclusivo" lógico. Esto puede ser útil para mostrar
texto en modo negativo, es decir, texto blanco sobre
fondo negro.
 SPI_T6963C_ROM_MODE_AND Modo: Los datos de texto y
gráficos que se muestran en la pantalla se combinan a
través de la "función AND" lógica.
 SPI_T6963C_ROM_MODE_TEXTModo: esta opción solo está
disponible cuando se muestra solo un texto. Los
valores de atributos de texto se almacenan en el área
gráfica de la memoria de visualización.
Para más detalles vea la hoja de datos de T6963C.
Requie El módulo Toshiba Glcd necesita ser inicializado. Ver

re la rutina SPI_T6963C_Config .
Ejempl SPI_T6963C_write_char ("A", 22,23,
o SPI_T6963C_ROM_MODE_AND);
SPI_T6963C_write_char_adv
Prototipo void SPI_T6963C_write_char_adv ( sin signo
char , sin signo int x, sin signo int y);
Descripción Escribe un carácter en el panel de texto actual de Glcd en

las coordenadas (x, y).
Parámetros  c: char para ser escrito

 x: posición char en el eje x
 y: posición char en el eje y
Devoluciones Nada.

Ejemplo SPI_T6963C_Write_Char_Adv ('A', 22,23);
Notas Ninguna.
SPI_T6963C_write_text
Prototi void SPI_T6963C_write_text ( unsigned char *
po str, unsigned char x, unsigned char y, unsigned
char mode);
Devolu Nada.
ciones
Descri Escribe texto en el panel de texto actual de Glcd en las

pción coordenadas (x, y).
Parámetros:
 str: texto para ser escrito
 x: posición del texto en el eje x
 y: posición del texto en el eje y
 mode:parámetro de modo Los valores
válidos: SPI_T6963C_ROM_MODE_OR, SPI_T6963C_ROM_MO
DE_XOR, SPI_T6963C_ROM_MODE_ANDySPI_T6963C_ROM_MO
DE_TEXT
Explicación de los parámetros de modo:
 SPI_T6963C_ROM_MODE_ORModo: En el modo OR, se
pueden mostrar texto y gráficos y los datos están
lógicamente "OR-ed". Esta es la forma más común de
combinar texto y gráficos, por ejemplo, etiquetas en
botones.
 SPI_T6963C_ROM_MODE_XORModo: En este modo, los
datos de texto y gráficos se combinan a través del "OR
exclusivo" lógico. Esto puede ser útil para mostrar
texto en modo negativo, es decir, texto blanco sobre
fondo negro.
 SPI_T6963C_ROM_MODE_AND Modo: Los datos de texto y
gráficos que se muestran en la pantalla se combinan a
través de la "función AND" lógica.
 SPI_T6963C_ROM_MODE_TEXTModo: esta opción solo está
disponible cuando se muestra solo un texto. Los
valores de atributos de texto se almacenan en el área
gráfica de la memoria de visualización.
Para más detalles vea la hoja de datos de T6963C.
Requie El módulo Toshiba Glcd necesita ser inicializado. Ver

re la rutina SPI_T6963C_Config .
Ejempl SPI_T6963C_write_text ("DEMO DE LA BIBLIOTECA Glcd,

o ¡BIENVENIDO!", 0, 0, SPI_T6963C_ROM_MODE_XOR);
SPI_T6963C_Write_Text_Adv
Prototipo void SPI_T6963C_Write_Text_Adv
( texto sin signo *, int sin signo x, int y sin
signo );
Descripción Escribe texto en el panel de texto actual de Glcd en las

coordenadas (x, y).
Parámetros  str: texto para ser escrito

Devoluciones Nada.

Ejemplo SPI_T6963C_Write_Text_Adv ("DEMO DE LA BIBLIOTECA

Glcd, ¡BIENVENIDO!", 0, 0);
Notas Ninguna.
SPI_T6963C_Write_Const_Text_Adv
Prototipo void SPI_T6963C_Write_Const_Text_Adv ( const far
char * text, unsigned int x, unsigned int y);
Parámetros  str: texto para ser escrito

Devoluciones Nada.


...
SPI_T6963C_Write_Const_Text_Adv (ctext, 0, 0);
Notas Ninguna.
SPI_T6963C_line
Prototipo void SPI_T6963C_line
( int x0, int y0, int x1, int y1, unsigned
char pcolor);
Devoluciones Nada.

Parámetros:
 x0: coordenada x de la línea de inicio
 y0: coordenada y del extremo de la línea
 x1: coordenada x de la línea de inicio
 y1: coordenada y del extremo de la línea
SPI_T6963C_INVERT.

Ejemplo SPI_T6963C_line (0, 0, 239, 127, SPI_T6963C_WHITE);
SPI_T6963C_rectangle
Prototipo void SPI_T6963C_rectangle
char pcolor);
Devoluciones Nada.
Parámetros:
 x0: coordenada x de la esquina superior
izquierda del rectángulo
 y0: coordenada y de la esquina superior
 x1: coordenada x de la esquina inferior derecha
del rectángulo
 y1: coordenada y de la esquina inferior derecha
del rectángulo
SPI_T6963C_INVERT.

Ejemplo SPI_T6963C_rectangle (20, 20, 219, 107,

SPI_T6963C_WHITE);
SPI_T6963C_rectangle_round_edges
Prototipo void SPI_T6963C_rectangle_round_edges
( int x0, int y0, int x1, inty1, int round_radius,
unsigned char pcolor);
Devolucion Nada.
es

Parámetros:
del rectángulo
del rectángulo
SPI_T6963C_INVERT.

la rutina SPI_T6963C_Config.
Ejemplo SPI_T6963C_rectangle_round_edges (20, 20, 219, 107,

12, SPI_T6963C_WHITE);
SPI_T6963C_rectangle_round_edges_fill
Prototipo void SPI_T6963C_rectangle_round_edges_fill
( int x0, int y0, int x1, inty1, int round_radius,
unsigned char pcolor);
Devolucion Nada.
es
Descripción Dibuja un borde redondeado relleno en Glcd.

Parámetros:
del rectángulo
del rectángulo
SPI_T6963C_INVERT.

Ejemplo SPI_T6963C_rectangle_round_edges_fill (20, 20, 219,

107, 12, SPI_T6963C_WHITE);
SPI_T6963C_box
Prototipo void SPI_T6963C_box
char pcolor);
Devoluciones Nada.
Descripción Dibuja una caja en el Glcd.

Parámetros:
izquierda del cuadro
izquierda del cuadro
del cuadro
del cuadro
SPI_T6963C_INVERT.
Ejemplo SPI_T6963C_box (0, 119, 239, 127, SPI_T6963C_WHITE);
SPI_T6963C_circle
Prototipo void SPI_T6963C_circle
( int x, int y, long r, unsigned charpcolor);
Devoluciones Nada.
Descripción Dibuja un círculo en el Glcd.

Parámetros:
 x: coordenada x del centro del círculo
 y: coordenada y del centro del círculo
 r: tamaño del radio
SPI_T6963C_INVERT.

Ejemplo SPI_T6963C_circle (120, 64, 110, SPI_T6963C_WHITE);
SPI_T6963C_circle_fill
Prototipo void SPI_T6963C_circle_fill
( int x, int y, long r, unsigned charpcolor);
Devoluciones Nada.
Descripción Dibuja un círculo relleno en el Glcd.

Parámetros:
 x: coordenada x del centro del círculo
 y: coordenada y del centro del círculo
 r: tamaño del radio
SPI_T6963C_INVERT.

Ejemplo SPI_T6963C_circle_fill (120, 64, 110,

SPI_T6963C_WHITE);
SPI_T6963C_image
Prototipo void SPI_T6963C_image ( const code char * pic);
Devoluciones Nada.

Parámetros:


Ejemplo SPI_T6963C_image (my_image);
SPI_T6963C_Ext_Image
Prototipo void SPI_T6963C_Ext_Image ( imagen larga sin
firmar );
Descripción Muestra un mapa de bits de un recurso externo.
Parámetros  pic:Imagen a mostrar. Este parámetro

imagen.
Devoluciones Nada.

Ejemplo SPI_T6963C_Ext_image (153608);
Notas La dimensión de la imagen debe coincidir con la dimensión

de visualización.
SPI_T6963C_PartialImage
Prototipo void SPI_T6963C_PartialImage ( sin signo
imagen);
Devoluciones Nada.

deseada.
Parámetros:



SPI_T6963C_PartialImage (10, 12, 10, 15, 16, 32,
imagen);
SPI_T6963C_Ext_PartialImage
Prototipo void SPI_T6963C_Ext_PartialImage ( sin signo

deseada.
imagen.
Devoluciones Nada.

Ejemplo SPI_T6963C_Ext_PartialImage (10, 12, 10, 15, 16, 32,

0);
Notas La dimensión de la imagen debe coincidir con la dimensión

de visualización.
SPI_T6963C_sprite
Prototipo void SPI_T6963C_sprite ( unsigned
char px, unsigned char py, const code char *
pic, unsigned char sx, unsigned char sy);
Devoluciones Nada.
Descripción Rellena el área del rectángulo gráfico (px, py) a (px + sx,
py + sy) con una imagen de tamaño personalizado.
Parámetros:
 px:Coordenada x de la esquina superior
izquierda de la imagen. Valores válidos:
múltiplos del ancho de la fuente.
 py: coordenada y de la esquina superior
izquierda de la imagen
 pic: imagen para mostrar
 sx:ancho de la imagen Valores válidos:
múltiplos del ancho de la fuente.
 sy: altura de la imagen
Nota: si pxy los sxparámetros no son múltiplos del
ancho de la fuente, se escalarán al número inferior más
cercano que sea un múltiplo del ancho de la fuente.

Ejemplo SPI_T6963C_sprite (76, 4, einstein, 88, 119); //

dibujar un sprite
SPI_T6963C_set_cursor
Prototipo void SPI_T6963C_set_cursor ( unsigned
char x, unsigned char y);
Devoluciones Nada.
Descripción Coloca el cursor en la fila x y la columna y.

Parámetros:
 x: posición del cursor número de fila
 y: posición del cursor número de columna

Ejemplo SPI_T6963C_set_cursor (cposx, cposy);
SPI_T6963C_clearbit
Prototipo void SPI_T6963C_clearBit ( char b);
Devoluciones Nada.
Descripción Borra el (los) bit (s) del puerto de control.

Parámetros:
 b:máscara de bits. La función se borrará
bit xen el puerto de control si bit xen bit mask
se establece en 1.

Ejemplo // borrar los bits 0 y 1 en el puerto de control

SPI_T6963C_clearBit (0x03);
SPI_T6963C_setBit
Prototipo void SPI_T6963C_setBit ( char b);
Devoluciones Nada.
Descripción Establece bit (s) de puerto de control.

Parámetros:
 b:máscara de bits. La función establecerá el
bit xen el puerto de control si el bit xen la
máscara de bit se establece en 1.

Ejemplo // establece los bits 0 y 1 en el puerto de control

SPI_T6963C_setBit (0x03);
SPI_T6963C_negBit
Prototipo nulo SPI_T6963C_negBit ( char b);
Devoluciones Nada.
Descripción Niega los bits de puerto de control.

Parámetros:
 b:máscara de bits. La función negará bit xen el
puerto de control si bit xen bit mask se
establece en 1.

Ejemplo // negar los bits 0 y 1 en el puerto de control

SPI_T6963C_negBit (0x03);
SPI_T6963C_DisplayGrPanel
Prototipo void SPI_T6963C_displayGrPanel ( char n);
Devoluciones Nada.
Descripción Mostrar el panel gráfico seleccionado.

Parámetros:
 n:Número de panel gráfico. Valores
válidos: 0y 1.
Ejemplo // mostrar el panel gráfico 1

SPI_T6963C_displayGrPanel (1);
SPI_T6963C_displayTxtPanel
Prototipo void SPI_T6963C_displayTxtPanel ( char n);
Devoluciones Nada.
Descripción Mostrar el panel de texto seleccionado.

Parámetros:
 n:Número de panel de texto. Valores
válidos: 0y 1.

Ejemplo // muestra el panel de texto 1

SPI_T6963C_displayTxtPanel (1);
SPI_T6963C_setGrPanel
Prototipo void SPI_T6963C_setGrPanel ( char n);
Devoluciones Nada.
Descripción Calcule la dirección de inicio para el panel gráfico

seleccionado y establezca los punteros internos
apropiados. Todas las operaciones gráficas subsiguientes
se realizarán en este panel gráfico.
Parámetros:
 n:Número de panel gráfico. Valores
válidos: 0y 1.

Ejemplo // establece el panel gráfico 1 como el panel

gráfico actual.
SPI_T6963C_setGrPanel (1);
SPI_T6963C_setTxtPanel
Prototipo void SPI_T6963C_setTxtPanel ( char n);
Devoluciones Nada.
Descripción Calcule la dirección de inicio para el panel de texto

seleccionado y establezca los punteros internos
apropiados. Todas las operaciones de texto subsiguientes
se realizarán en este panel de texto.
Parámetros:
 n:Número de panel de texto. Valores
válidos: 0y 1.

Ejemplo // establece el panel de texto 1 como el panel de

texto actual.
SPI_T6963C_setTxtPanel (1);
SPI_T6963C_panelFill
Prototipo void SPI_T6963C_panelFill ( unsigned char v);
Devoluciones Nada.
Descripción Llene el panel actual por completo (gráfico + texto) con el

valor apropiado (0 para borrar).
Parámetros:
 v: Valor para llenar el panel con.

Ejemplo borrar panel actual

SPI_T6963C_panelFill (0);
SPI_T6963C_grFill
Prototipo void SPI_T6963C_grFill ( unsigned char v);
Devoluciones Nada.
Descripción Llene el panel gráfico actual con el valor apropiado (0 para

borrar).
Parámetros:
 v: Valor para llenar el panel gráfico con.
Ejemplo // borrar el panel gráfico actual

SPI_T6963C_grFill (0);
SPI_T6963C_txtFill
Prototipo void SPI_T6963C_txtFill ( unsigned char v);
Devoluciones Nada.
Descripción Rellene el panel de texto actual con el valor apropiado (0

para borrar).
Parámetros:
 v: este valor aumentado en 32 se utilizará para
rellenar el panel de texto.

Ejemplo // borrar el panel de texto actual

SPI_T6963C_txtFill (0);
SPI_T6963C_cursor_height
Prototipo void SPI_T6963C_cursor_height ( unsigned char n);
Devoluciones Nada.
Descripción Establecer el tamaño del cursor.

Parámetros:
 n:altura del cursor. Los valores válidos: 0.. 7.

Ejemplo SPI_T6963C_cursor_height (7);
SPI_T6963C_graphics
Prototipo void SPI_T6963C_graphics ( char n);
Devoluciones Nada.
Descripción Habilitar / deshabilitar la visualización de gráficos.
Parámetros:
 n:gráfico habilitar / deshabilitar
parámetro. Valores válidos: 0(deshabilitar la
visualización de gráficos) y 1(habilitar la
visualización gráfica).

Ejemplo // habilitar la visualización gráfica

SPI_T6963C_graphics (1);
SPI_T6963C_text
Prototipo void SPI_T6963C_text ( char n);
Devoluciones Nada.
Descripción Habilitar / deshabilitar la visualización de texto.

Parámetros:
 n:parámetro de habilitar / deshabilitar
texto. Valores válidos: 0(deshabilitar el envío
de texto) y 1(habilitar la visualización del
texto).

Ejemplo // habilitar la visualización de texto

SPI_T6963C_text (1);
SPI_T6963C_cursor
Prototipo void SPI_T6963C_cursor ( char n);
Devoluciones Nada.
Descripción Poner el cursor en on / off.

Parámetros:
 n:parámetro de encendido / apagado. Valores
válidos: 0(coloque el cursor en off) y 1(coloque
el cursor en).

Ejemplo // coloca el cursor en
SPI_T6963C_cursor (1);
SPI_T6963C_cursor_blink
Prototipo void SPI_T6963C_cursor_blink ( char n);
Devoluciones Nada.
Descripción Habilitar / deshabilitar el cursor parpadeando.

Parámetros:
 n:cursor parpadeante habilitar / deshabilitar
parámetro. Valores válidos: 0(deshabilita el
cursor parpadeando) y 1(habilita el cursor
parpadeando).

Ejemplo // habilitar el cursor parpadeando

SPI_T6963C_cursor_blink (1);
La siguiente demostración de dibujo prueba las rutinas avanzadas de la biblioteca
SPI T6963C Glcd. Las configuraciones de hardware en este ejemplo están hechas
para la pantalla T6963C 240x128, la placa EasyPIC6 y el 16F887.
#include "__SPIT6963C.h"
/ *
* Imágenes de mapa de bits almacenadas en ROM
* /
const code char mikroE_240x64_bmp []; // PIC16F887 no puede almacenar
una imagen más grande (240x128) en ROM
const code char einstein [];

void main () {
char txt1 [] = "EINSTEIN LE GUSTARÍA ME";
char txt [] = "DEMO DE LA BIBLIOTECA GLCD, ¡BIENVENIDO!";
panel de charla sin firmar ; // Panel actual

unsigned int i; // Registro de propósito general
unsigned char curs; // Visibilidad del cursor
unsigned int cposx, cposy; // posición del cursor xy
#define COMPLETE_EXAMPLE // comente esta línea para simplificar /
reducir el ejemplo ANSEL = 0; // Configurar pines AN
como E / S digital
ANSELH = 0;
C2ON_bit = 0;
TRISB0_bit = 1; // Establecer RB0 como entrada



/ *
* Pantalla de inicio para 240 píxeles de ancho y 128 píxeles de altura.
* Ancho de caracteres de 8 bits.
* bus de datos en el puerto MCP23S17
* bus de control en el puerto MCP23S17
* el bit 2 es! WR
* el bit 1 es! RD
* el bit 0 es! CD
* el bit 4 es RST
* chip habilitado, inverso, fuente 8x8 establecida internamente en la
biblioteca
* /
SPI_T6963C_Config (240, 128, 8, 0, 2, 1, 0, 4);

Delay_ms (1000);
/ *
* Habilita la visualización de gráficos y texto al mismo tiempo
* /
panel = 0;
i = 0;
curs = 0;
cposx = cposy = 0;
/ *
* Mensajes de texto
* /
SPI_T6963C_write_text (txt, 0, 0, SPI_T6963C_ROM_MODE_XOR);
SPI_T6963C_write_text (txt1, 0, 15, SPI_T6963C_ROM_MODE_XOR);
/ *
* Cursor
* /
SPI_T6963C_cursor_height (8); // 8 píxeles de altura
SPI_T6963C_set_cursor (0, 0); // mover el cursor a la parte
superior izquierda
SPI_T6963C_cursor (0); // cursor apagado
/ *
* Dibujar rectángulos
* /
SPI_T6963C_rectangle (0, 0, 239, 127, SPI_T6963C_WHITE);
/ *
* Dibujar una cruz
* /
SPI_T6963C_line (0, 0, 239, 127, SPI_T6963C_WHITE);
SPI_T6963C_line (0, 127, 239, 0, SPI_T6963C_WHITE);
/ *
* Dibujar cajas sólidas.
* /
SPI_T6963C_box (0, 0, 239, 8, SPI_T6963C_WHITE);
SPI_T6963C_box (0, 119, 239, 127, SPI_T6963C_WHITE);
/ *
* Dibujar círculos
* /
SPI_T6963C_circle (120, 64, 10, SPI_T6963C_WHITE);
SPI_T6963C_sprite (76, 4, einstein, 88, 119); // dibujar un

sprite
SPI_T6963C_setGrPanel (1); // Seleccionar

otro panel gráfico
SPI_T6963C_sprite (0, 0, mikroE_240x64_bmp, 240, 64); // 240x128 no se

puede almacenar en la mayoría de las MCU
PIC16 SPI_T6963C_sprite (0, 64, mikroE_240x64_bmp, 240, 64); // se
reemplaza con una imagen más pequeña 240x64
// La imagen más
pequeña se dibuja dos veces
#terminara si
para (;;) { // Endless

loop
/ *
* Si se presiona RB0, muestra solo el panel gráfico
* /
if (RB0_bit) {
Delay_ms (300);
}
/ *
* Si se presiona RB1, alterne la visualización entre el panel
gráfico 0 y el panel gráfico 1
* /
else if (RB1_bit) {
panel ++;
panel & = 1;
SPI_T6963C_displayGrPanel (panel);
Delay_ms (300);
}
#terminara si
/ *
* Si se presiona RB2, muestra solo el panel de texto
* /
else if (RB2_bit) {
Delay_ms (300);
}
/ *
* Si se presiona RB3, se muestran los paneles de texto y gráficos.
* /
else if (RB3_bit) {
Delay_ms (300);
}
/ *
* Si se presiona RB4, cambia el cursor
* /
else if (RB4_bit) {
curs ++;
if (curs == 3) curs = 0;
interruptor (curs) {
caso 0:
// sin cursor
romper ;
caso 1:
// cursor parpadeante
romper ;
caso 2:
// cursor sin parpadear
romper ;
}
Delay_ms (300);
}
/ *
* Mover el cursor, incluso si no es visible
* /
cposx ++;
if (cposx == SPI_T6963C_txtCols) {
cposx = 0;
c ++ ++;
if (cposy == SPI_T6963C_grHeight / SPI_T6963C_CHARACTER_HEIGHT) {
cposy = 0;
}
}
SPI_T6963C_set_cursor (cposx, cposy);
Delay_ms (100);
}
}
Conexión HW
Conexión SPI T6963C Glcd HW
Biblioteca TFT
La pantalla de cristal líquido (TFT-LCD) con transistor de película delgada es una
variante de la pantalla de cristal líquido (LCD) que utiliza la tecnología de transistor
de película delgada (TFT) para mejorar la calidad de la imagen (por ejemplo,
direccionabilidad, contraste).
TFT LCD es un tipo de LCD de matriz activa, aunque todas las pantallas LCD se
basan en el direccionamiento de matriz activa TFT.
Las pantallas TFT LCD se utilizan en televisores, monitores de computadoras,
teléfonos móviles, sistemas de videojuegos portátiles, asistentes digitales
personales, sistemas de navegación, proyectores, etc.
El mikroC PRO for PIC proporciona una biblioteca para trabajar con los siguientes
controladores de pantalla:
 Himax HX8347G,
 Solomon Systech SSD1963,
 Renesas SP R61526,
 Sitronix SST7715R.
Nota :
 Cuando conecte la pantalla TFT a la MCU use traductores de voltaje de

5V a 3.3V (si MCU es un dispositivo de 5V). En cualquier otro caso
puedes dañar el TFT!
 La biblioteca trabaja solo con la familia PIC18.
 Todos los controladores de pantalla se inicializan con 65,536 colores (R
(5), G (6), B (5)).
Dependencias externas de la biblioteca TFT
deben definirse en
Descripció
todos los proyectos que Ejemplo:
n:
utilizan la biblioteca
TFT:
extern sfr Puerto de

char TFT_DataPort atLATD;
charTFT_DataPort; datos TFT.
Dirección
extern sfr
del puerto charTFT_DataPort_Direction at TRI
charTFT_DataPort_Directi
on; de datos SD;
TFT.
Escribir
extern sfr sbit TFT_WR; sbit TFT_WR atLATE1_bit;
señal.
extern sfr sbit TFT_RD;

Leer la sbit TFT_RD atLATE0_bit;
señal.
Señal de
extern sfr sbit TFT_CS; selección de sbit TFT_CS atLATG3_bit;
chip.
Señal de
selección de
extern sfr sbit TFT_RS; sbit TFT_RS atLATH6_bit;
comando /
registro.
Restablecer
extern sfr sbit TFT_RST; sbit TFT_RST atLATH4_bit;
la señal.
Dirección
extern sfr sbit TFT_WR_Direction at TRISE1_b
sbitTFT_WR_Direction; del pin de it;
escritura.
Dirección
extern sfr sbit TFT_WR_Direction at TRISE0_b
sbitTFT_RD_Direction; del pin de it;
lectura.
Dirección
extern sfr sbit TFT_CS_Direction at TRISG3_b
sbitTFT_CS_Direction; del pin Chip it;
Select.
Dirección
extern sfr del registro sbit TFT_RS_Direction at TRISH6_b
sbitTFT_RS_Direction; Seleccionar it;
pin.
Dirección
extern sfr sbit TFT_RST_Direction at TRISH4_
sbitTFT_RST_Direction; del pin de bit;
reinicio.
 TFT_Init
 TFT_Init_HX8347G
 TFT_Init_SSD1963_8bit
 TFT_Init_R61526
 TFT_Init_SST7715R
 TFT_Init_ILI9340_8bit
 TFT_Init_ILI9481_8bit
 TFT_Set_Index
 TFT_Write_Command
 TFT_Write_Data
 TFT_Set_Reg
 TFT_Set_Ext_Buffer
 TFT_Set_Active
 TFT_Set_Default_Mode
 TFT_Set_Font
 TFT_Set_Ext_Font
 TFT_Write_Char
 TFT_Write_Text
 TFT_Write_Const_Text
 TFT_Fill_Screen
 TFT_Set_Pen
 TFT_Set_Brush
 TFT_Dot
 TFT_Line
 TFT_H_Line
 TFT_V_Line
 TFT_Rectangle
 TFT_Rectangle_Round_Edges
 TFT_Círculo
 TFT_Imagen
 TFT_Ext_Image
 TFT_Partial_Image
 TFT_Ext_Partial_Image
 TFT_Image_Jpeg
 TFT_RGBToColor16bit
 TFT_Color16bitToRGB
 TFT_Rotate_180
TFT_Init
Prototipo void TFT_Init ( unsigned
int display_width, unsigned chardisplay_height);
Devoluciones Nada.
Descripción Inicializa la pantalla del controlador de pantalla HX8347-D

en el modo de trabajo de 8 bits.
Parámetros:
 width: ancho del panel TFT
 height: altura del panel TFT

 TFT_DataPort: Puerto de datos
 TFT_WR: Pin de señal de escritura
 TFT_RD: Pin de señal de lectura
 TFT_CS: Pin de señal de selección de chip
 TFT_RS: Registro Seleccionar señal pin
 TFT_RST: Restablecer pin de señal
 TFT_DataPort_Direction: Dirección del puerto

de datos
 TFT_WR_Direction: Dirección de la señal de
escritura del pin
 TFT_RD_Direction: Dirección del pin de señal
de lectura
 TFT_CS_Direction: Dirección del pin de señal
Chip Select
 TFT_RS_Direction: Dirección de registro
Seleccionar señal pin
 TFT_RST_Direction: Dirección del pin de señal
de reinicio
Ejemplo // TFT muestra las conexiones

char TFT_DataPort en LATD;
sbit TFT_WR en LATE1_bit;
sbit TFT_RD en LATE0_bit;
sbit TFT_CS en LATG3_bit;
sbit TFT_RS en LATH6_bit;
sbit TFT_RST en LATH4_bit;
char TFT_DataPort_Direction en TRISD;

sbit TFT_WR_Direction: en TRISE1_bit;
sbit TFT_RD_Direction at TRISE0_bit;
sbit TFT_CS_Direction at TRISG3_bit;
sbit TFT_RS_Direction at TRISH6_bit;
sbit TFT_RST_Direction at TRISH4_bit;
// Fin de las conexiones de pantalla TFT
// Inicializar 240x320 pantalla TFT

TFT_Init (240, 320);
TFT_Init_HX8347G
Prototipo void TFT_Init_HX8347G ( unsigned
Devoluciones Nada.
Descripción Inicializa la pantalla del controlador de pantalla HX8347-G

Parámetros:


de datos
escritura del pin
de lectura
Chip Select
de reinicio



TFT_Init_HX8347G (240, 320);
TFT_Init_SSD1963_8bit
Prototipo void TFT_Init_SSD1963_8bit ( unsigned
int display_width, unsigned char display_height);
Devoluciones Nada.
Descripción Inicializa la pantalla del controlador de pantalla SSD1963

Parámetros:


de datos
escritura del pin
de lectura
Chip Select
de reinicio



TFT_Init_SSD1963_8bit (240, 320);
TFT_Init_R61526
Prototipo void TFT_Init_R61526 ( unsigned
Devoluciones Nada.
Descripción Inicializa la pantalla del controlador de pantalla R61526 en

el modo de trabajo de 8 bits.
Parámetros:


de datos
escritura del pin
de lectura
Chip Select
de reinicio



TFT_Init_R61526 (240, 320);
TFT_Init_SST7715R
Prototipo void TFT_Init_SST7715R ( unsigned
Devoluciones Nada.
Descripción Inicializa la pantalla del controlador de pantalla SST7715R

Parámetros:


de datos
TFT_WR_Direction: Dirección de la señal de
escritura del pin
de lectura
Chip Select
de reinicio


TFT_Init_SST7715R (240, 320);
TFT_Init_ILI9340_8bit
Prototipo void TFT_Init_ILI9340_8bit ( unsigned
Devoluciones Nada.
Descripción Inicializa la pantalla del controlador de pantalla ILI9340 en

Parámetros:


de datos
escritura del pin
de lectura
Chip Select
de reinicio


TFT_Init_ILI9340_8bit (240, 320);
TFT_Init_ILI9481_8bit
Prototipo void TFT_Init_ILI9481_8bit ( unsigned
Devoluciones Nada.
Descripción Inicializa la pantalla del controlador de pantalla ILI9481 en

Parámetros:


de datos
escritura del pin
de lectura
Chip Select
de reinicio



TFT_Init_ILI9481_8bit (240, 320);
TFT_Set_Index
Prototipo void TFT_Set_Index ( índice corto sin signo );
Devoluciones Nada.
Descripción Accede al espacio de registro del controlador y establece el

registro deseado.
Parámetros:
 index: Número de registro deseado.
Requiere El módulo TFT necesita ser inicializado. Por favor, vea

la rutina de inicialización TFT apropiada .
Ejemplo // Acceso al registro en la ubicación 0x02.

TFT_Set_Index (0x02);
TFT_Write_Command
Prototipo void TFT_Write_Command ( cmd corto sin firmar );
Devoluciones Nada.
Descripción Accede al espacio de datos y escribe un comando.

Parámetros:
 cmd: Mandato a ser escrito.

Ejemplo // escribe un comando

TFT_Write_Command (0x02);
TFT_Write_Data
Prototipo void TFT_Write_Data ( unsigned int _data);
Devoluciones Nada.
Descripción Escribe la fecha en la memoria de pantalla.

Parámetros:
 _data:Datos a escribir.

Ejemplo // Enviar datos

TFT_Write_Data (0x02);
TFT_Set_Reg
Prototipo void TFT_Set_Reg ( índice corto
sin signo , valor corto sin signo);
Devoluciones Nada.
Descripción Accede al espacio de registro del controlador y escribe un

valor en el registro deseado.
Parámetros:
 index: registro deseado.
 value: Valor a escribir.

Ejemplo // 65K Selección de color

TFT_Set_Reg (0x17, 0x05);
TFT_Set_Ext_Buffer
Prototipo void TFT_Set_Ext_Buffer (char * (* getExtDataPtr)
( desplazamiento largo sin signo , cuenta int
sin signo , int * num sin signo ));
Devoluciones Nada.

Parámetros:
bytes adquiridos).


unsigned int pos;
offset / 512;
} else
}
* num = 512-pos;
}
más
* num = cuenta;

}
TFT_Set_Ext_Buffer (ReadExternalBuffer);
TFT_Set_Active
Prototipo void TFT_Set_Active ( void (* Set_Index_Ptr) ( sin
signo corto ), void (* Write_Command_Ptr) ( sin
signo ), void (* Write_Data_Ptr) ( sin signo
int ));
Devoluciones Nada.
Descripción Esta función establece los punteros apropiados para las

rutinas básicas definidas por el usuario con el fin de
habilitar múltiples modos de trabajo.
Parámetros:
 Set_Index_Ptr: Controlador Set_Index.
 Write_Command_Ptr: _Write_Command
handler.
 Write_Data_Ptr: Write_Data handler.
Requiere Ninguna.
Ejemplo // Ejemplo de establecimiento de comunicación de 16

bits entre la pantalla TFT y PORTD, PORTE de MCU:
void Set_Index ( índice corto sin firmar ) {

TFT_RS = 0;
Lo (LATD) = índice;
TFT_WR = 0;
TFT_WR = 1;
}
void Write_Command ( cmd corto sin firmar ) {

TFT_RS = 1;
Lo (LATD) = cmd;
TFT_WR = 0;
TFT_WR = 1;
}
void Write_Data ( unsigned int _data) {

TFT_RS = 1;
Lo (TARDE) = Hola (_data);
Lo (LATD) = Lo (_data);
TFT_WR = 0;
TFT_WR = 1;
}
void main () {
TRISE = 0;
TRISD = 0;
TFT_Set_Active (Set_Index, Write_Command,

Write_Data);
TFT_Init (320, 240);
.....
}
TFT_Set_Default_Mode
Prototipo void TFT_Set_Default_Mode ();
Devoluciones Nada.
Descripción Esta función establece TFT en el modo de trabajo

predeterminado.
Parámetros:
 Ninguna.
Requiere Ninguna.
Ejemplo TFT_Set_Default_Mode ();

TFT_Init (320, 240);
TFT_Set_Font
Prototipo void TFT_Set_Font ( const char far *
intfont_color, char font_orientation);
Devoluciones Nada.
Descripción Establece la fuente, su color y su orientación.

Parámetros:
 activeFont:fuente deseada Actualmente, solo
se TFT_defaultFontadmite (Tahoma14x16).
 font_color: establece el color de la fuente:
Valor Descripción
CL_AQUA Color aguamarina
CL_BLACK De color negro
CL_BLUE Color azul
CL_FUCHSIA Color fucsia
CL_GRAY color gris
CL_GREEN Color verde
CL_LIME Color lima
CL_MAROON Color marrón
CL_NAVY azul marino
CL_OLIVE Color verde oliva
CL_PURPLE Color púrpura
CL_RED color rojo
CL_SILVER Color plata

CL_TEAL De color verde azulado
CL_WHITE el color blanco
CL_YELLOW Color amarillo
 font_orientation: establece la orientación de

la fuente:
Valor Descripción
FO_HORIZONTAL Orientación horizontal
FO_VERTICAL Orientación vertical

Ejemplo TFT_Set_Font (TFT_defaultFont, CL_BLACK,

FO_HORIZONTAL);
TFT_Set_Ext_Font
Prototipo void TFT_Set_Ext_Font ( unsigned long *
Devoluciones Nada.
Descripción Establece la fuente, su color y su orientación. La fuente se

encuentra en un recurso externo
Parámetros:
 activeFont:fuente deseada Este parámetro
Valor Descripción
CL_BLUE Color azul

CL_GRAY color gris
CL_LIME Color lima
CL_NAVY azul marino
CL_RED color rojo

la fuente:
Valor Descripción
FO_HORIZONTAL Orientación horizontal
FO_VERTICAL Orientación vertical

Ejemplo TFT_Set_Ext_Font (173296, CL_BLACK, FO_HORIZONTAL);

TFT_Write_Char
Prototipo void TFT_Write_Char ( unsigned int c, unsigned
int x, unsigned inty);
Devoluciones Nada.
Descripción Escribe un char en el TFT en las coordenadas (x, y).


Ejemplo TFT_Write_Char ('A', 22,23);
TFT_Write_Text
Prototipo void TFT_Write_Text ( unsigned char *
Devoluciones Nada.
Descripción Escribe texto en el TFT en las coordenadas (x, y).

Parámetros:

Ejemplo TFT_Write_Text ("DEMO DE LA BIBLIOTECA DE TFT,

¡BIENVENIDO!", 0, 0);
TFT_Write_Const_Text
Prototipo void TFT_Write_Const_Text ( const char *
Devoluciones Nada.
Descripción Escribe el texto ubicado en la memoria del programa en la

TFT en las coordenadas (x, y).
Parámetros:

...
TFT_Write_Const_Text (ctext, 0, 0);
TFT_Fill_Screen
Prototipo void TFT_Fill_Screen ( sin signo int color);
Devoluciones Nada.
Descripción Rellena el bloque de memoria de pantalla con el color

dado.
Parámetros:
 color: color a rellenar:
Valor Descripción
CL_BLUE Color azul
CL_GRAY color gris
CL_LIME Color lima
CL_NAVY azul marino

CL_RED color rojo

Ejemplo TFT_Fill_Screen (CL_BLACK);
TFT_Dot
Prototipo void TFT_Dot ( int x, int y, unsigned int color);
Devoluciones Nada.
Descripción Dibuja un punto en el TFT en las coordenadas (x, y).

Parámetros:
Valor Descripción
CL_BLUE Color azul
CL_GRAY color gris

CL_LIME Color lima
CL_NAVY azul marino
CL_RED color rojo

Ejemplo TFT_Dot (50, 50, CL_BLACK);
TFT_Set_Pen
Prototipo void TFT_Set_Pen ( unsigned
int pen_color, char pen_width);
Devoluciones Nada.
Descripción Establece los parámetros de color y grosor para dibujar

elementos de línea, círculo y rectángulo.
Parámetros:
 pen_color: Establece el color.
Valor Descripción

CL_BLUE Color azul
CL_GRAY color gris
CL_LIME Color lima
CL_NAVY azul marino
CL_RED color rojo
 pen_width: conjuntos de espesor.

Ejemplo TFT_Set_Pen (CL_BLACK, 10);
TFT_Set_Brush
Prototip void TFT_Set_Brush ( char brush_enabled, unsigned
o int brush_color, chargradient_enabled, char gradient_o
rientation, unsigned intgradient_color_from, unsigned
int gradient_color_to);
Devoluci Nada.
ones
Descripc Establece el color y el degradado que se utilizarán para rellenar

ión círculos o rectángulos.
Parámetros:
 brush_enabled: habilitar el relleno del cepillo.
Valor Descripción
1 Habilitar relleno de pincel.
0 Desactivar el relleno del cepillo.
 brush_color: establecer el color de relleno del

cepillo.
Valor Descripción
CL_BLUE Color azul
CL_GRAY color gris
CL_LIME Color lima
CL_NAVY azul marino

CL_RED color rojo
 gradient_enabled: habilitar gradiente

Valor Descripción
1 Habilitar gradiente.
0 Desactivar gradiente.
 gradient_orientation: establece la orientación del

gradiente:
Valor Descripción
DE IZQUIERDA A Orientación de gradiente de izquierda

DERECHA a derecha
DE ARRIBA HACIA Orientación de gradiente de arriba a

ABAJO abajo
 gradient_color_from: Establece el color de

gradiente inicial.
Valor Descripción
CL_BLUE Color azul

CL_GRAY color gris
CL_LIME Color lima
CL_NAVY azul marino
CL_RED color rojo
 gradient_color_to: establece el color degradado

final.
Valor Descripción
CL_BLUE Color azul

CL_GRAY color gris
CL_LIME Color lima
CL_NAVY azul marino
CL_RED color rojo
Requiere El módulo TFT necesita ser inicializado. Por favor, vea la rutina
de inicialización TFTapropiada .
Ejemplo // Habilitar degradado de color negro a blanco,

orientación izquierda-derecha
TFT_Set_Brush (0, 0, 1, LEFT_TO_RIGHT, CL_BLACK,
CL_WHITE);
TFT_Line
Prototipo void TFT_Line ( int x1, int y1, int x2, int y2);
Devoluciones Nada.

Parámetros:

Ejemplo TFT_Line (0, 0, 239, 127);
TFT_H_Line
Prototipo void TFT_H_Line
( int x_start, int x_end, int y_pos);
Devoluciones Nada.
Descripción Dibuja una línea horizontal en TFT.

Parámetros:
 y_pos: y coordenada de linea horizontal.

la rutina de inicialización TFTapropiada .

(10,20) y (50,20)
TFT_H_Line (10, 50, 20);
TFT_V_Line
Prototipo void TFT_V_Line
( int y_start, int y_end, int x_pos);
Devoluciones Nada.
Descripción Dibuja una línea vertical en TFT.

Parámetros:
 x_pos: coordenada x de linea vertical.


y (10,25)
TFT_V_Line (5, 25, 10);
TFT_Rectangle
Prototip void TFT_Rectangle
o ( int x_upper_left, int y_upper_left, intx_bottom_rig
ht, int y_bottom_right);
Devoluci Nada.
ones
Descripci Dibuja un rectángulo en TFT.

ón Parámetros:
 x_upper_left: Coordenada x de la esquina superior
 y_upper_left: Coordenada y de la esquina superior
de inicialización TFT apropiada .
Ejemplo TFT_Rectangle (20, 20, 219, 107);
TFT_Rectangle_Round_Edges
Prototipo void TFT_Rectangle_Round_Edges ( unsigned
int x_upper_left, unsigned
int y_upper_left, unsigned
int x_bottom_right, unsigned
int y_bottom_right, unsigned int round_radius);
Devoluciones Nada.
Descripción Dibuja un borde redondeado rectángulo en TFT.

Parámetros:

Ejemplo TFT_Rectangle_Round_Edges (20, 20, 219, 107, 12);

TFT_Círculo
Prototipo void TFT_Circle
( int x_center, int y_center, int radius);
Devoluciones Nada.
Descripción Dibuja un círculo en TFT.

Parámetros:
 x: Coordenada x del centro del círculo.
 y: Y coordenada del centro del círculo.
 r: tamaño del radio.

Ejemplo TFT_Circle (120, 64, 110);
TFT_Imagen
Prototipo void TFT_Image ( sin signo int izquierda, sin
signo int arriba, código constante sin signo con
poca imagen *, sin signo conextensión);
Devoluciones Nada.
Descripción Muestra una imagen en una ubicación deseada.

Parámetros:
 left: Posición del borde izquierdo de la
imagen.
 top:Posición del borde superior de la imagen.
 stretch: estira la imagen por un factor dado
(si es 2, doblará la imagen).

Ejemplo TFT_Image (0, 0, imagen, 1);
TFT_Ext_Image
Prototipo void TFT_Ext_Image ( sin signo int izquierda, sin
signo intarriba, imagen sin firmar larga , sin
signo estiramiento corto );
Devoluciones Nada.
Descripción Muestra una imagen de un recurso externo en una
dirección deseada.
Parámetros:
imagen.
imagen.

Ejemplo TFT_Image (0, 0, 153608, 1);
TFT_Partial_Image
Prototipo void TFT_Partial_Image ( sin signo
int izquierda, sin signo int arriba, sin signo
int ancho, sin signo int alto, código const hasta
ahora sin signo corto *, sin signo corto tramo);
Devoluciones Nada.

deseada.
Parámetros:
 left: coordenada izquierda de la imagen.
 top: Coordenada superior de la imagen.

Ejemplo // Dibuja una parte 10x15 de la imagen comenzando

desde la esquina superior izquierda en la coordenada
(10,12)
TFT_Partial_Image (10, 12, 10, 15, imagen, 1);
TFT_Ext_Partial_Image
Prototipo void TFT_Ext_Partial_Image ( unsigned
int izquierda, unsigned intsuperior, unsigned
int anchura, unsigned int altura, largo sin
signo imagen, corto sin signo de estiramiento);
Devoluciones Nada.

Parámetros:
imagen.

Ejemplo TFT_Ext_Partial_Image (159,0,160,120,0,1);
TFT_Image_Jpeg
Prototipo char TFT_Image_Jpeg ( unsigned int left, unsigned
int top, code const unsigned short * image);
Devoluciones  0 - Si la imagen está cargada y se muestra con

éxito.
 1 - si se produjo un error.
Descripción Muestra una imagen JPEG en una ubicación deseada.

Parámetros:

Ejemplo TFT_Image_Jpeg (0, 0, imagen);
TFT_RGBToColor16bit
Prototipo unsigned int TFT_RGBToColor16bit
( char rgb_red, char rgb_green, char rgb_blue);
Devoluciones Devuelve un valor de color en el siguiente orden de bits: 5
bits de color rojo, 6 bits de color verde y 5 bits de color
azul.
Descripción Convierte el formato 5: 6: 5 RGB en formato de color

verdadero.
Parámetros:
 rgb_red: Componente rojo de la imagen.
 rgb_green: Componente verde de la imagen.
 rgb_blue: Componente azul de la imagen.

Ejemplo color16 = TFT_RGBToColor16bit (150, 193, 65);
TFT_Color16bitToRGB
Prototipo void TFT_Color16bitToRGB ( sin signo
int color, char * rgb_red, char *
rgb_green, char * rgb_blue);
Devoluciones Nada.
Descripción Convierte el color verdadero en formato 5: 6: 5 RGB.

Parámetros:
 color: Color verdadero para convertir.
 rgb_red: Componente rojo del color de
entrada.
 rgb_green: Componente verde del color de
entrada.
 rgb_blue: Componente azul del color de
entrada.

Ejemplo TFT_Color16bitToRGB (start_color, & red_start, &

green_start, & blue_start);
TFT_Rotate_180
Prototipo void TFT_Rotate_180 ( char rotate );
Devoluciones Nada.
Descripción Gira la pantalla TFT.

Parámetros:
 rotate:Parámetro para pantalla
giratoria. Valores válidos:
 0: la pantalla no se girará.
 1 - la pantalla girará 180 grados.

Ejemplo // Girar la pantalla TFT de 180 grados

TFT_Rotate_180 (1);
// Inicializar la pantalla TFT

TFT_Init (240, 320);
Conexión HW
Conexión TFT HW
Biblioteca TFT de 16 bits

La pantalla de cristal líquido (TFT-LCD) con transistor de película delgada es una
variante de la pantalla de cristal líquido (LCD) que utiliza la tecnología de transistor
de película delgada (TFT) para mejorar la calidad de la imagen (por ejemplo,
direccionabilidad, contraste).
TFT LCD es un tipo de LCD de matriz activa, aunque todas las pantallas LCD se
basan en el direccionamiento de matriz activa TFT.
Las pantallas TFT LCD se utilizan en televisores, monitores de computadoras,
teléfonos móviles, sistemas de videojuegos portátiles, asistentes digitales
personales, sistemas de navegación, proyectores, etc.
El mikroC PRO for PIC proporciona una biblioteca para trabajar con los siguientes
controladores de pantalla:
 Himax HX8347D y HX8352A,
 Solomon Systech SSD1963,
 Ilitek ILI9340, ILI9342 e ILI9481.
Nota :
 Cuando conecte la pantalla TFT a la MCU use traductores de voltaje de

5V a 3.3V (si MCU es un dispositivo de 5V). En cualquier otro caso
puedes dañar el TFT!
 La biblioteca trabaja solo con la familia PIC18.
 Todos los controladores de pantalla se inicializan con 65,536 colores (R
(5), G (6), B (5)) y requieren dos puertos completos para la operación
(debido a la interfaz de 16 bits).
Dependencias externas de la biblioteca TFT de 16 bits
deben definirse en todos Descripc
Ejemplo:
los proyectos utilizando la ión:
biblioteca TFT de 16 bits:
Puerto de
extern sfr char TFT_16bit_DataPort_Lo atLAT
charTFT_16bit_DataPort_Lo; datos TFT B;
bajo.
Puerto de
extern sfr char TFT_16bit_DataPort_Hi atLAT
charTFT_16bit_DataPort_Hi; datos TFT C;
alto.
Dirección
extern sfr del
charTFT_16bit_DataPort_Hi_Direct
charTFT_16bit_DataPort_Hi_ puerto de ion at TRISB;
Direction; datos TFT
bajo.
Dirección
extern sfr del
charTFT_16bit_DataPort_Lo_Direct
charTFT_16bit_DataPort_Lo_ puerto de ion at TRISC;
Direction; datos TFT
Alto.
extern sfr Escribir

sbit TFT_16bit_WR at LATE1_bit;
sbit TFT_16bit_WR; señal.
extern sfr Leer la

sbit TFT_16bit_RD at LATE0_bit;
sbit TFT_16bit_RD; señal.
Señal de
extern sfr
sbit TFT_16bit_CS; selección sbit TFT_16bit_CS at LATG3_bit;
de chip.
Señal de
selección
extern sfr
sbit TFT_16bit_RS; de sbit TFT_16bit_RS at LATH6_bit;
comando
/ registro.
Restablec
extern sfr
sbit TFT_16bit_RST; er la sbit TFT_16bit_RST atLATH4_bit;
señal.

sbit TFT_16bit_WR_Direction atTR
sbitTFT_16bit_WR_Direction del pin de ISE1_bit;
; escritura.

sbit TFT_16bit_WR_Direction atTR
sbitTFT_16bit_RD_Direction del pin de ISE0_bit;
; lectura.
Dirección
extern sfr
sbitTFT_16bit_CS_Direction
del pin sbit TFT_16bit_CS_Direction atTR
; Chip ISG3_bit;
Select.
Dirección
extern sfr del
sbit TFT_16bit_RS_Direction atTR
sbitTFT_16bit_RS_Direction registro ISH6_bit;
; Seleccion
ar pin.

sbit TFT_16bit_RST_Direction atT
sbitTFT_16bit_RST_Directio del pin de RISH4_bit;
n; reinicio.
 TFT_Init_HX8347D
 TFT_Init_HX8352A
 TFT_Init_SSD1963
 TFT_Init_ILI9340
 TFT_Init_HX8347G_16bit
 TFT_16bit_Set_Index
 TFT_16bit_Write_Command
 TFT_16bit_Write_Data
 TFT_16bit_Set_Reg
 TFT_16bit_Set_Ext_Buffer
 TFT_16bit_Set_Active
 TFT_16bit_Set_Default_Mode
 TFT_16bit_Set_Font
 TFT_16bit_Set_Ext_Font
 TFT_16bit_Write_Char
 TFT_16bit_Write_Text
 TFT_16bit_Write_Const_Text
 TFT_16bit_Fill_Screen
 TFT_16bit_Set_Pen
 TFT_16bit_Set_Brush
 TFT_16bit_Dot
 TFT_16bit_Line
 TFT_16bit_H_Line
 TFT_16bit_V_Line
 TFT_16bit_Rectangle
 TFT_16bit_Rectangle_Round_Edges
 TFT_16bit_Circle
 TFT_16bit_Image
 TFT_16bit_Ext_Image
 TFT_16bit_Partial_Image
 TFT_16bit_Ext_Partial_Image
 TFT_16bit_Image_Jpeg
 TFT_16bit_RGBToColor16bit
 TFT_16bit_Color16bitToRGB
 TFT_16bit_Rotate_180
TFT_Init_HX8347D
Prototipo void TFT_Init_HX8347D ( unsigned
Devoluciones Nada.
Descripción Inicializa el controlador de pantalla HX8347D en modo de

trabajo de 16 bits.
Parámetros:
 width: Ancho de la pantalla TFT.
 height: Altura de la pantalla TFT.

 TFT_16bit_DataPort_Lo: Puerto de datos bajo
 TFT_16bit_DataPort_Hi: Puerto de datos alto
 TFT_16bit_WR: Pin de señal de escritura
 TFT_16bit_RD: Pin de señal de lectura
 TFT_16bit_CS: Pin de señal de selección de
chip
 TFT_16bit_RS: Registro Seleccionar señal pin
 TFT_16bit_RST: Restablecer pin de señal
 TFT_16bit_DataPort_Direction_Lo: Dirección
de puerto de datos bajo
 TFT_16bit_DataPort_Direction_Hi: Dirección
de Puerto de Datos Alto
 TFT_16bit_WR_Direction: Dirección de la señal
de escritura del pin
 TFT_16bit_RD_Direction: Dirección del pin de
señal de lectura
 TFT_16bit_CS_Direction: Dirección del pin de
señal Chip Select
 TFT_16bit_RS_Direction: Dirección de registro
 TFT_16bit_RST_Direction: Dirección del pin de
señal de reinicio

char TFT_16bit_DataPort_Lo en LATB;
char TFT_16bit_DataPort_Hi en LATC;
sbit TFT_16bit_WR en LATE1_bit;
sbit TFT_16bit_RD en LATE0_bit;
sbit TFT_16bit_CS en LATG3_bit;
sbit TFT_16bit_RS en LATH6_bit;
sbit TFT_16bit_RST en LATH4_bit;
char TFT_16bit_DataPort_Lo_Direction en TRISB;

char TFT_16bit_DataPort_Hi_Direction en TRISC;
sbit TFT_16bit_WR_Direction: en TRISE1_bit;
sbit TFT_16bit_RD_Direction at TRISE0_bit;
sbit TFT_16bit_CS_Direction at TRISG3_bit;
sbit TFT_16bit_RS_Direction at TRISH6_bit;
sbit TFT_16bit_RST_Direction at TRISH4_bit;

TFT_Init_HX8347D (240, 320);
TFT_Init_HX8352A
Prototipo void TFT_Init_HX8352A ( unsigned
Devoluciones Nada.
Descripción Inicializa el controlador de pantalla HX8352A en modo de

trabajo de 16 bits.
Parámetros:

chip
señal de lectura
señal Chip Select
señal de reinicio



TFT_Init_HX8352A (240, 320);
TFT_Init_SSD1963
Prototipo void TFT_Init_SSD1963 ( unsigned
Devoluciones Nada.
Descripción Inicializa el controlador de pantalla SSD1963 en modo de

trabajo de 16 bits.
Parámetros:

chip
señal de lectura
señal Chip Select
señal de reinicio



TFT_Init_SSD1963 (240, 320);
TFT_Init_ILI9340
Prototipo void TFT_Init_ILI9340 ( unsigned
Devoluciones Nada.
Descripción Inicializa el controlador de pantalla ILI9340 en modo de
trabajo de 16 bits.
Parámetros:

chip
señal de lectura
señal Chip Select
señal de reinicio



TFT_Init_ILI9340 (240, 320);
TFT_Init_ILI9342
Devoluciones Nada.

trabajo de 16 bits.
Parámetros:

chip
señal de lectura
señal Chip Select
señal de reinicio


TFT_Init_ILI9342 (240, 320);
TFT_Init_ILI9481
Devoluciones Nada.

trabajo de 16 bits.
Parámetros:

chip
señal de lectura
señal Chip Select
señal de reinicio


TFT_Init_ILI9481 (240, 320);
TFT_Init_HX8347G_16bit
Prototipo void TFT_Init_HX8347G_16bit ( unsigned
Devoluciones Nada.
Descripción Inicializa el controlador de pantalla HX8347G en modo de

trabajo de 16 bits.
Parámetros:

chip
señal de lectura
señal Chip Select
señal de reinicio


TFT_Init_HX8347G_16bit (240, 320);
TFT_16bit_Set_Index
Prototipo void TFT_16bit_Set_Index ( índice corto sin
signo );
Devoluciones Nada.
Descripción Accede al espacio de registro del controlador y establece el

registro deseado.
Parámetros:
 index: Número de registro deseado.

Ejemplo // Acceso al registro en la ubicación 0x02.

TFT_16bit_Set_Index (0x02);
TFT_16bit_Write_Command
Prototipo void TFT_16bit_Write_Command ( cmd corto sin
signo );
Devoluciones Nada.
Descripción Accede al espacio de datos y escribe un comando.

Parámetros:
 cmd: Mandato a ser escrito.

Ejemplo // escribe un comando
TFT_16bit_Write_Command (0x02);
TFT_16bit_Write_Data
Prototipo void TFT_16bit_Write_Data ( unsigned int _data);
Devoluciones Nada.
Descripción Escribe la fecha en la memoria de pantalla.

Parámetros:
 _data:Datos a escribir.

Ejemplo // Enviar datos

TFT_16bit_Write_Data (0x02);
TFT_16bit_Set_Reg
Prototipo void TFT_16bit_Set_Reg ( índice corto
sin signo , valor corto sin signo );
Devoluciones Nada.
Descripción Accede al espacio de registro del controlador y escribe un

valor en el registro deseado.
Parámetros:
 index: registro deseado.
 value: Valor a escribir.

Ejemplo // 65K Selección de color

TFT_16bit_Set_Reg (0x17, 0x05);
TFT_16bit_Set_Ext_Buffer
Prototipo void TFT_16bit_Set_Ext_Buffer (char * (*
getExtDataPtr) ( desplazamiento largo sin signo ,
cuenta int sin signo , int * num sin signo ));
Devoluciones Nada.
Parámetros:
bytes adquiridos).


unsigned int pos;
offset / 512;
} else
}
* num = 512-pos;
}
más
* num = cuenta;

}
TFT_16bit_Set_Ext_Buffer (ReadExternalBuffer);
TFT_16bit_Set_Active
Prototipo void TFT_16bit_Set_Active ( void (* Set_Index_Ptr)
( sin signo corto ), void (* Write_Command_Ptr)
( sin signo corto ), void (* Write_Data_Ptr) ( sin
signo int ));
Devoluciones Nada.
Descripción Esta función establece los punteros apropiados para las

rutinas básicas definidas por el usuario con el fin de
habilitar múltiples modos de trabajo.
Parámetros:
 Set_Index_Ptr: Controlador Set_Index.
 Write_Command_Ptr: _Write_Command
handler.
 Write_Data_Ptr: Write_Data handler.
Requiere Ninguna.
Ejemplo Por favor, vea la hoja de datos del controlador para las
descripciones del modo de trabajo.
void Set_Index ( índice corto sin signo ) {
// Establecer índice
}
void Write_Command ( cmd corto sin signo ) {

// Write Command
}
void Write_Data ( unsigned int _data) {

// Write Data
}
void main () {
...
TFT_Set_Active (Set_Index, Write_Command,
Write_Data);
TFT_Init_HX8352A (320, 240);
...
}
TFT_16bit_Set_Default_Mode
Prototipo void TFT_16bit_Set_Default_Mode ();
Devoluciones Nada.
Descripción Esta función establece TFT en el modo de trabajo

predeterminado.
Parámetros:
 Ninguna.
Requiere Ninguna.
Ejemplo TFT_16bit_Set_Default_Mode ();

TFT_Init_HX8352A (320, 240);
TFT_16bit_Set_Font
Prototipo void TFT_16bit_Set_Font ( const char far *
Devoluciones Nada.
Descripción Establece la fuente, su color y su orientación.

Parámetros:
 activeFont:fuente deseada Actualmente, solo
se TFT_16bit_defaultFontadmite
(Tahoma14x16).
Valor Descripción
CL_AQUA_16bit Color aguamarina
CL_BLACK_16bit De color negro
CL_BLUE_16bit Color azul
CL_FUCHSIA_16bit Color fucsia
CL_GRAY_16bit color gris
CL_GREEN_16bit Color verde
CL_LIME_16bit Color lima
CL_MAROON_16bit Color marrón
CL_NAVY_16bit azul marino
CL_OLIVE_16bit Color verde oliva
CL_PURPLE_16bit Color púrpura
CL_RED_16bit color rojo
CL_SILVER_16bit Color plata
CL_TEAL_16bit De color verde azulado
CL_WHITE_16bit el color blanco

CL_YELLOW_16bit Color amarillo

la fuente:
Valor Descripción
FO_HORIZONTAL_16bit Orientación horizontal
FO_VERTICAL_16bit Orientación vertical

Ejemplo TFT_16bit_Set_Font (TFT_16bit_defaultFont,

CL_BLACK_16bit, FO_HORIZONTAL_16bit);
TFT_16bit_Set_Ext_Font
Prototipo void TFT_16bit_Set_Ext_Font ( unsigned long *
int font_color, char font_orientation);
Devoluciones Nada.
Descripción Establece la fuente, su color y su orientación. La fuente se

encuentra en un recurso externo
Parámetros:
 activeFont:fuente deseada Este parámetro
Valor Descripción

CL_WHITE_16bit / td> el color blanco

la fuente:
Valor Descripción
FO_HORIZONTAL_16bit Orientación horizontal
FO_VERTICAL_16bit Orientación vertical

Ejemplo TFT_16bit_Set_Ext_Font (173296, CL_BLACK_16bit,

FO_HORIZONTAL_16bit);
TFT_16bit_Write_Char
Prototipo void TFT_16bit_Write_Char ( unsigned
int c, unsigned int x, unsigned int y);
Devoluciones Nada.
Descripción Escribe un char en el TFT en las coordenadas (x, y).


Ejemplo TFT_16bit_Write_Char ('A', 22,23);
TFT_16bit_Write_Text
Prototipo void TFT_16bit_Write_Text ( unsigned char *
text, unsigned int x, unsigned inty);
Devoluciones Nada.
Descripción Escribe texto en el TFT en las coordenadas (x, y).

Parámetros:

Ejemplo TFT_16bit_Write_Text ("TFT DEMO de la biblioteca de

16 bits, ¡BIENVENIDO!", 0, 0);
TFT_16bit_Write_Const_Text
Prototipo void TFT_16bit_Write_Const_Text ( const far char *
Devoluciones Nada.
Descripción Escribe el texto ubicado en la memoria del programa en la

TFT en las coordenadas (x, y).
Parámetros:

...
TFT_16bit_Write_Const_Text (ctext, 0, 0);
TFT_16bit_Fill_Screen
Prototipo void TFT_16bit_Fill_Screen ( sin signo int color);
Devoluciones Nada.
Descripción Rellena el bloque de memoria de pantalla con el color

dado.
Parámetros:
 color: color a rellenar:
Valor Descripción


Ejemplo TFT_16bit_Fill_Screen (CL_BLACK_16bit);
TFT_16bit_Dot
Prototipo void TFT_16bit_Dot ( int x, int y, unsigned
int color);
Devoluciones Nada.
Descripción Dibuja un punto en el TFT en las coordenadas (x, y).

Parámetros:
Valor Descripción


Ejemplo TFT_16bit_Dot (50, 50, CL_BLACK_16bit);
TFT_16bit_Set_Pen
Prototipo void TFT_16bit_Set_Pen ( unsigned
int pen_color, char pen_width);
Devoluciones Nada.
Descripción Establece los parámetros de color y grosor para dibujar

elementos de línea, círculo y rectángulo.
Parámetros:
 pen_color: Establece el color.
Valor Descripción

 pen_width: conjuntos de espesor.

Ejemplo TFT_16bit_Set_Pen (CL_BLACK_16bit, 10);
TFT_16bit_Set_Brush
Prototip void TFT_16bit_Set_Brush
o ( char brush_enabled, unsigned
int brush_color, chargradient_enabled, char gradient_o
rientation, unsigned intgradient_color_from, unsigned
int gradient_color_to);
Devoluci Nada.
ones
Descripc Establece el color y el degradado que se utilizarán para rellenar

ión círculos o rectángulos.
Parámetros:
 brush_enabled: habilitar el relleno del cepillo.
Valor Descripción
1 Habilitar relleno de pincel.
0 Desactivar el relleno del cepillo.
 brush_color: establecer el color de relleno del

cepillo.
Valor Descripción

 gradient_enabled: habilitar gradiente

Valor Descripción
1 Habilitar gradiente.
0 Desactivar gradiente.
 gradient_orientation: establece la orientación del

gradiente:
Valor Descripción
LEFT_TO_RIGHT_16bit Orientación de gradiente de

izquierda a derecha
TOP_TO_BOTTOM <_16bit / Orientación de gradiente de

td> arriba a abajo
 gradient_color_from: Establece el color de

gradiente inicial.
Valor Descripción

 gradient_color_to: establece el color degradado

final.
Valor Descripción

de inicialización TFTapropiada .
Ejemplo // Habilitar degradado de color negro a blanco,

orientación izquierda-derecha
TFT_16bit_Set_Brush (0, 0, 1, LEFT_TO_RIGHT_16bit,
CL_BLACK_16bit, CL_WHITE_16bit);
TFT_16bit_Line
Prototipo void TFT_16bit_Line
( int x1, int y1, int x2, int y2);
Devoluciones Nada.

Parámetros:

Ejemplo TFT_16bit_Line (0, 0, 239, 127);
TFT_16bit_H_Line
Prototipo void TFT_16bit_H_Line
( int x_start, int x_end, int y_pos);
Devoluciones Nada.
Descripción Dibuja una línea horizontal en TFT.

Parámetros:
 y_pos: y coordenada de linea horizontal.


(10,20) y (50,20)
TFT_16bit_H_Line (10, 50, 20);
TFT_16bit_V_Line
Prototipo void TFT_16bit_V_Line
( int y_start, int y_end, int x_pos);
Devoluciones Nada.
Descripción Dibuja una línea vertical en TFT.

Parámetros:
 x_pos: coordenada x de linea vertical.


y (10,25)
TFT_16bit_V_Line (5, 25, 10);
TFT_16bit_Rectangle
Prototip void TFT_16bit_Rectangle
o ( int x_upper_left, int y_upper_left, intx_bottom_rig
ht, int y_bottom_right);
Devoluci Nada.
ones
Descripci Dibuja un rectángulo en TFT.

ón Parámetros:
 x_upper_left: Coordenada x de la esquina superior
 y_upper_left: Coordenada y de la esquina superior
de inicialización TFT apropiada .
Ejemplo TFT_16bit_Rectangle (20, 20, 219, 107);
TFT_16bit_Rectangle_Round_Edges
Prototipo void TFT_16bit_Rectangle_Round_Edges ( unsigned
int x_upper_left, unsigned
int y_upper_left, unsigned
int x_bottom_right, unsigned
int y_bottom_right, unsigned int round_radius);
Devoluciones Nada.
Descripción Dibuja un borde redondeado rectángulo en TFT.

Parámetros:

Ejemplo TFT_16bit_Rectangle_Round_Edges (20, 20, 219, 107,

12);
TFT_16bit_Circle
Prototipo void TFT_16bit_Circle
( int x_center, int y_center, int radius);
Devoluciones Nada.
Descripción Dibuja un círculo en TFT.

Parámetros:
 x: Coordenada x del centro del círculo.
 y: Y coordenada del centro del círculo.
 r: tamaño del radio.

Ejemplo TFT_16bit_Circle (120, 64, 110);
TFT_16bit_Image
Prototipo void TFT_16bit_Image ( sin signo
int izquierda, sin signo intarriba, código
constante hasta ahora sin firmar *
imagen corta , sin signo , extensión corta );
Devoluciones Nada.
Descripción Muestra una imagen en una ubicación deseada.

Parámetros:
imagen.

Ejemplo TFT_16bit_Image (0, 0, imagen, 1);
TFT_16bit_Ext_Image
Prototipo void TFT_16bit_Ext_Image ( sin signo
int izquierda, sin signo intarriba, sin
firmar imagen larga , sin
signo estiramiento corto );
Devoluciones Nada.
Descripción Muestra una imagen de un recurso externo en una
dirección deseada.
Parámetros:
imagen.
imagen.

Ejemplo TFT_16bit_Image (0, 0, 153608, 1);
TFT_16bit_Partial_Image
Prototipo void TFT_16bit_Partial_Image ( sin signo
int ancho, sin signo int alto, código const hasta
ahora sin signo imagen corta *, sin signo
corto tramo);
Devoluciones Nada.

deseada.
Parámetros:

Ejemplo // Dibuja una parte 10x15 de la imagen comenzando

desde la esquina superior izquierda en la coordenada
(10,12)
TFT_16bit_Partial_Image (10, 12, 10, 15, imagen, 1);
TFT_16bit_Ext_Partial_Image
Prototipo void TFT_16bit_Ext_Partial_Image ( sin signo
int ancho, sin signo int altura, sin signo
larga imagen, sin signo corto tramo);
Devoluciones Nada.

Parámetros:
imagen.

Ejemplo TFT_16bit_Ext_Partial_Image (159,0,160,120,0,1);
TFT_16bit_Image_Jpeg
Prototipo char TFT_16bit_Image_Jpeg ( unsigned
int left, unsigned int top, code const lejos
unsigned short * image);
Devoluciones  0 - Si la imagen está cargada y se muestra con

éxito.
 1 - si se produjo un error.
Descripción Muestra una imagen JPEG en una ubicación deseada.

Parámetros:

Ejemplo TFT_16bit_Image_Jpeg (0, 0, imagen);
TFT_16bit_RGBToColor16bit
Prototipo unsigned int TFT_16bit_RGBToColor16bit
( char rgb_red, charrgb_green, char rgb_blue);
Devoluciones Devuelve un valor de color en el siguiente orden de bits: 5

bits de color rojo, 6 bits de color verde y 5 bits de color
azul.
Descripción Convierte el formato 5: 6: 5 RGB en formato de color

verdadero.
Parámetros:
 rgb_red: Componente rojo de la imagen.
 rgb_green: Componente verde de la imagen.
 rgb_blue: Componente azul de la imagen.

Ejemplo color16 = TFT_16bit_RGBToColor16bit (150, 193, 65);
TFT_16bit_Color16bitToRGB
Prototipo void TFT_16bit_Color16bitToRGB ( sin signo
int color, char * rgb_red, char *
rgb_green, char * rgb_blue);
Devoluciones Nada.
Descripción Convierte el color verdadero en formato 5: 6: 5 RGB.

Parámetros:
 color: Color verdadero para convertir.
 rgb_red: Componente rojo del color de
entrada.
 rgb_green: Componente verde del color de
entrada.
 rgb_blue: Componente azul del color de
entrada.

Ejemplo TFT_16bit_Color16bitToRGB (start_color, & red_start,

& green_start, & blue_start);
TFT_16bit_Rotate_180
Prototipo void TFT_16bit_Rotate_180 ( char rotate );
Devoluciones Nada.
Descripción Gira la pantalla TFT.
Parámetros:
 rotate:Parámetro para pantalla
giratoria. Valores válidos:
 0: la pantalla no se girará.
 1 - la pantalla girará 180 grados.

Ejemplo // Girar la pantalla TFT de 180 grados

TFT_16bit_Rotate_180 (1);
// Inicializar la pantalla TFT

TFT_Init_HX8352A (240, 320);
Biblioteca de panel táctil

El mikroC PRO para PIC proporciona una biblioteca para trabajar con el panel táctil.
Dependencias externas de la biblioteca del panel táctil

Las siguientes
variables deben
definirse en todos Descripción
Ejemplo:
los proyectos usando :
la Biblioteca de
Panel Táctil:
extern sfr
sbit DriveA; Línea DriveA. sbit DriveA atRC0_bit;
extern sfr
sbit DriveB; Línea DriveB. sbit DriveB atRC1_bit;
extern sfr
Dirección del sbitDriveA_Direction at TRISC0_bit
sbitDriveA_Direction
; pin DriveA. ;
extern sfr
Dirección del sbitDriveB_Direction at TRISC1_bit
sbitDriveB_Direction
; pin DriveB. ;
 TP_Init
 TP_Set_ADC_Threshold
 TP_Press_Detect
 TP_Get_Coordinates
 TP_Calibrate_Bottom_Left
 TP_Calibrate_Upper_Right
 TP_Get_Calibration_Consts
 TP_Set_Calibration_Consts
TP_Init
Prototipo void TP_Init ( unsigned
int display_width, unsigned
intdisplay_height, char readX_ChNo, char readY_ChN
o);
Descripción Inicializar panel táctil. El valor umbral predeterminado del

panel táctil ADC se establece en 3900.
Parámetros  display_width: establecer el ancho de

visualización.
 display_height: establecer la altura de
visualización.
 readX_ChNo:lea la coordenada X
del canal ADC deseado .
 readY_ChNo:lea la coordenada Y
del canal ADC deseado .
Devolucione Nada.
s
Requiere Antes de llamar a esta función inicialice el módulo ADC .
Ejemplo ADC_Init (); // Initalizar el módulo

ADC
TP_Init (128, 64, 6, 7); // Inicializar panel
táctil, dimensiones 128x64
TP_Set_ADC_Threshold
Prototipo void TP_Set_ADC_Threshold ( umbral int sin
signo );
Descripción Establezca un valor de umbral ADC personalizado , llame a

esta función después TP_Init.
Parámetros  threshold:valor de umbral ADC personalizado .
Devoluciones Nada.
Requiere TP_Init Tiene que ser llamado antes de usar esta rutina.
Ejemplo TP_Set_ADC_Threshold (3900); // Establecer el

umbral ADC del panel táctil
TP_Press_Detect
Prototipo char TP_Press_Detect ();
Descripción Detecta si el panel táctil ha sido presionado.
Devoluciones  1 - Si se presiona el panel táctil.


 DriveA: DriveA.
 DriveB: DriveB.
 DriveA_Direction: Dirección del pin DriveA.
 DriveB_Direction: Dirección del pin DriveB.
Ejemplo // Conexiones del módulo del panel táctil

sbit DriveA at RC0_bit;
sbit DriveB en RC1_bit;
sbit DriveA_Direction en TRISC0_bit;
sbit DriveB_Direction at TRISC1_bit;
// Terminar las conexiones del módulo del panel
táctil
if (TP_Press_Detect ()) {
...
}
TP_Get_Coordinates
Prototipo char TP_Get_Coordinates ( unsigned int *
x_coordinate, unsigned int * y_coordinate);
Descripción Obtén las coordenadas del panel táctil y guárdalas

en x_coordinatey y_coordinateparámetros.
Parámetros  x_coordinate: X coordenada del lugar de

contacto.
 y_coordinate: Y coordenada del lugar de
contacto.
Devoluciones  0 - si la lectura está dentro del rango de

dimensión de visualización.
 1 - si la lectura está fuera del rango de
dimensión de la pantalla.
Requiere Nada.
Ejemplo if (TP_Get_Coordinates (& x_coord, & y_coord) == 0)

{
...
}
TP_Calibrate_Bottom_Left
Prototipo void TP_Calibrate_Bottom_Left ();
Descripción Calibrar la esquina inferior izquierda del panel táctil.
Devoluciones Nada.
Requiere Nada.
Ejemplo TP_Calibrate_Bottom_Left (); // Calibración de la

esquina inferior izquierda
TP_Calibrate_Upper_Right
Prototipo void TP_Calibrate_Upper_Right ();
Descripción Calibrar la esquina superior derecha del panel táctil.
Devoluciones Nada.
Requiere Nada.
Ejemplo TP_Calibrate_Upper_Right (); // Calibración de la

esquina superior derecha
TP_Get_Calibration_Consts
Prototipo void TP_Get_Calibration_Consts ( unsigned int *
x_min, unsigned int * x_max, unsigned int *
y_min, unsigned int * y_max);
Descripción Obtiene constantes de calibración después de la calibración

se lleva a cabo y los almacena
en x_min, x_max, y_miny y_maxparámetros.
Parámetros  x_min: Coordenada x de la esquina inferior
izquierda del área de trabajo.
 x_max: Coordenada x de la esquina superior
derecha del área de trabajo.
 y_min: Coordenada y de la esquina inferior
 y_max: y coordenada de la esquina superior
Devoluciones Nada.
Requiere Nada.
Ejemplo TP_Get_Calibration_Consts (& x_min, & y_min, &

x_max, & y_max); // Obtener constantes de
calibración
TP_Set_Calibration_Consts
Prototipo void TP_Set_Calibration_Consts ( unsigned
int x_min, unsigned int x_max, unsigned
inty_min, unsigned int y_max);
Descripción Establece las constantes de calibración.
Parámetros  x_min: Coordenada x de la esquina inferior

 x_max: Coordenada x de la esquina superior
 y_min: Coordenada y de la esquina inferior
 y_max: y coordenada de la esquina superior
Devoluciones Nada.
Requiere Nada.
Ejemplo TP_Set_Calibration_Consts (148, 3590, 519, 3370);

// Establecer las constantes de calibración
La siguiente demostración de dibujo prueba las rutinas de la biblioteca del Panel
táctil:
// Conexiones del módulo Glcd



// Terminar las conexiones del módulo Glcd
// Conexiones del módulo del panel táctil

sbit DriveA at RC0_bit;
sbit DriveB en RC1_bit;
sbit DriveA_Direction en TRISC0_bit;
sbit DriveB_Direction at TRISC1_bit;
// Terminar las conexiones del módulo del panel táctil
bit write_erase;
char pen_size;
char write_msg [] = "WRITE"; // Mensajes
del menú
GLCD char clear_msg [] = "CLEAR";
char erase_msg [] = "ERASE";
unsigned int x_coord, y_coord;
void Initialize () {
DriveA_Direction = 0; // Establecer
el pin DriveA como salida
DriveB_Direction = 0; // Establecer
el pin DriveB como salida
ANSEL = 3; // Configure los
pines AN0 y AN1 como entradas analógicas
ANSELH = 0; // y otros
TRISA = 3;
comparadores
C2ON_bit = 0;
Glcd_Init (); // Inicializar

GLCD Glcd_Fill (0); // Borrar
GLCD
ADC_Init (); // Inicializar

ADC
TP_Init (128, 64, 0, 1); // Inicializar
panel táctil
TP_Set_ADC_Threshold (900); // Establecer
el umbral ADC del panel táctil
}
void Calibrate () {
Glcd_Dot (0,63,1); // Dibujar el

punto inferior izquierdo
Glcd_Write_Text ("TOUCH BOTTOM LEFT", 12,3,1);
TP_Calibrate_Bottom_Left (); // Calibración
de la esquina inferior izquierda
Delay_ms (1000);
Glcd_Dot (0,63,0); // Borrar el

punto inferior izquierdo
Glcd_Dot (127,0,1); // dibujar el
punto superior derecho
Glcd_Write_Text ("", 12,3,1);
Glcd_Write_Text ("TOUCH UPPER RIGHT", 12,4,1);
TP_Calibrate_Upper_Right (); // Calibración
de la esquina superior derecha
Delay_ms (1000);
}
void main () {
Inicializar();
Glcd_Write_Text ("CALIBRATION", 32,3,1);

Delay_ms (1000);
Glcd_Fill (0); // Borrar GLCD
Calibrar();
Glcd_Fill (0);
Glcd_Write_Text ("WRITE ON SCREEN", 20, 5, 1);
Delay_ms (1000);
Glcd_Fill (0); // Borrar GLCD

Glcd_V_Line (0,7,0,1);
Glcd_Write_Text (clear_msg, 1,0,0);
Glcd_V_Line (0,7,97,1);
Glcd_Write_Text (erase_msg, 98,0,0);
// Menú de la pluma:
Glcd_Rectangle (41,0,52,9,1);
Glcd_Box (45,3,48,6,1);
Glcd_Box (66,3,67,4,1);
Glcd_Dot (83,3,1);
write_erase = 1;
pen_size = 1;
mientras (1) {
if (TP_Press_Detect ()) {
// Después de que se detecte un PRESS, lea XY y
conviértalo a un espacio de 128x64 si (TP_Get_Coordinates (&
x_coord, & y_coord) == 0) {
if ((x_coord <31) && (y_coord <8)) {
Glcd_Fill (0);
// Menú de la pluma:
Glcd_Box (45,3,48,6,1);
Glcd_Box (66,3,67,4,1);
Glcd_Dot (83,3,1);
Glcd_V_Line (0,7,0,1);
Glcd_Write_Text (clear_msg, 1,0,0);
Glcd_V_Line (0,7,97,1);
if (write_erase)
más
Glcd_Write_Text (write_msg, 98,0,0);
}
// Si se presiona write / erase

if ((x_coord> 96) && (y_coord <8)) {
if (write_erase) {
write_erase = 0;
Glcd_Write_Text (write_msg, 98,0,0);
Delay_ms (500);
}
else {
write_erase = 1;
Delay_ms (500);
}
}
// Si se selecciona el tamaño de la pluma

si ((x_coord> = 41) && (x_coord <= 52) && (y_coord <= 9))
pen_size = 3;
if ((x_coord> = 63) && (x_coord <= 70) && (y_coord <= 7))
pen_size = 2;
if ((x_coord> = 80) && (x_coord <= 86) && (y_coord <= 6))
pen_size = 1;
si (y_coord <11)
continúa ;
cambiar (tamaño de la pluma) {

caso 1: {
if ((x_coord> = 0) && (y_coord> = 0) && (x_coord <=
127) && (y_coord <= 63))
Glcd_Dot (x_coord, y_coord, write_erase);
romper ;
}
caso 2: {
127-1) && (y_coord <= 63-1))
Glcd_Box (x_coord, y_coord, x_coord + 1, y_coord +
1, write_erase);
romper ;
}
caso 3: {
127-2) && (y_coord <= 63-2))
Glcd_Box (x_coord-1, y_coord-1, x_coord + 2,
y_coord + 2, write_erase);
romper ;
}
}
}
}
}
}
<Error>
<Code>NoSuchKey</Code>
<Message>The specified key does not exist.</Message>
<Key>
documents/compilers/mikroc/pic/help/tft_touch_panel_library.htm.htm
</Key>
<RequestId>55D4D7C473445980</RequestId>
<HostId>
BThomAo8yAu1AdDxVp/usnJO32ZhzPb76uaezNTeUZV6mdIbp0b4qcvFwYRIg6VpKPkEwt
2vCK4=
</HostId>
</Error>
Biblioteca UART
El módulo de hardware UART está disponible con una serie de MCU compatibles con
PIC. La biblioteca mikroC PRO for PIC UART proporciona un trabajo cómodo con el
modo asíncrono (dúplex completo).
HW). Necesita un PIC MCU con UART integrado por hardware, por ejemplo
16F887. Luego, simplemente use las funciones enumeradas a continuación.
Importante:
 Las rutinas de la biblioteca UART requieren que especifique el módulo

que desea usar. Para seleccionar el módulo UART deseado ,
simplemente cambie la letra x en el prototipo de rutina para un número
del 1 al 2 .
 La conmutación entre los módulos UART en la biblioteca UART se realiza
mediante la función UART_Set_Active (los módulos UART deben
inicializarse previamente).
 El número de módulos UART por MCU difiere de un chip a otro. Por
favor, lea la hoja de datos correspondiente antes de utilizar esta
biblioteca.
 UARTx_Init
 UARTx_Data_Ready
 UARTx_Tx_Idle
 UARTx_Read
 UARTx_Read_Text
 UARTx_Write
 UARTx_Write_Text
 UART_Set_Active
Rutinas genéricas
 UART_Data_Listo
 UART_Tx_Idle
 UART_Leer
 UART_Read_Text
 UART_escribir
 UART_Write_Text
UARTx_Init
Prototipo void UARTx_Init ( const unseded long baud_rate);
Devoluciones Nada.
Descripción Inicializa el módulo UART de hardware deseado con la

velocidad en baudios deseada. Consulte la hoja de datos
del dispositivo para conocer las velocidades en baudios
permitidas para cada específico Fosc. Si especifica la
velocidad en baudios no admitida, el compilador informará
un error.
Requiere Necesitas PIC MCU con hardware UART .

UARTx_Initdebe llamarse antes de usar otras funciones de
la Biblioteca UART .
Parámetros:

biblioteca.
Ejemplo // Inicialice el hardware UART1 y establezca la

comunicación a 9600 bps
UART1_Init (9600);
UARTx_Data_Ready
Prototipo char UARTx_Data_Ready ();




}
UARTx_Tx_Idle
Prototipo char UARTx_Tx_Idle ();



if (UART1_Tx_Idle () == 1) {
}
UARTx_Read
Prototipo char UARTx_Read ();

función UARTx_Data_Ready para probar si los datos


}
UARTx_Read_Text
Prototipo void UARTx_Read_Text ( char * Salida, char *
Devoluciones Nada.

Parámetros:

Delay_ms (100);
while (1) {
datos
}
}
UARTx_Write
Prototipo void UARTx_Write ( char data_);
Devoluciones Nada.

Parámetros:


...
UARTx_Write_Text
Prototipo void UARTx_Write_Text ( char * UART_text);
Devoluciones Nada.

terminado en cero.
Parámetros:


Delay_ms (100);
while (1) {
datos
}
}
UART_Set_Active
Prototipo void UART_Set_Active ( char (* read_ptr)
(), void (* write_ptr) ( unsigned
char data_), char (* ready_ptr) (), char (*
tx_idle_ptr) ())
Devoluciones Nada.
Descripción Establece el módulo UART activo que será utilizado por

las rutinas de la biblioteca UART .
Parámetros:
 read_ptr: UARTx_Read handler
 write_ptr: UARTx_Write manejador
 ready_ptr: UARTx_Data_Ready handler
 tx_idle_ptr: UARTx_Tx_Idle handler
Requiere La rutina solo está disponible para MCU con

dos módulos UART .
El módulo UART usado debe inicializarse antes de usar esta
rutina. Ver la rutina UARTx_Init.
Ejemplo UART1_Init (9600); // inicializar

el módulo
UART1 UART2_Init (9600); //
inicializar el módulo UART2
RS485Master_Init (); // inicializar

MCU como maestro

UART1 RS485Master_Send activo
(dat, 1,160); // enviar mensaje a través de
UART1

UART2 activo
RS485Master_Send (dat, 1,160); // enviar a
través de UART2
UART_Data_Listo
Prototipo char UART_Data_Ready ();



léalos : if (UART_Data_Ready () == 1) {
receive = UART_Read ();
}
UART_Tx_Idle
Prototipo char UART_Tx_Idle ();




if (UART_Tx_Idle () == 1) {
UART_Write (_data);
}
UART_Leer
Prototipo char UART_Read ();

función UART_Data_Readypara probar si los datos


léalos : if (UART_Data_Ready () == 1) {
receive = UART_Read ();
}
UART_Read_Text
Prototipo void UART_Read_Text ( char * Salida, char *
Devoluciones Nada.

Parámetros:


Delay_ms (100);
while (1) {
if (UART_Data_Ready () == 1) {// si se reciben
datos
UART_Read_Text (salida, "OK", 10); // lee el
UART_Write_Text (salida); // devuelve el texto
}
}
UART_escribir
Prototipo void UART_Write ( char data_);
Devoluciones Nada.

Parámetros:


...
UART_Write (_data);
UART_Write_Text
Prototipo void UART_Write_Text ( char * UART_text);
Devoluciones Nada.

terminado en cero.
Parámetros:


Delay_ms (100);
while (1) {
if (UART_Data_Ready () == 1) {// si se reciben
datos
UART_Read_Text (salida, "OK", 10); // lee el
UART_Write_Text (salida); // devuelve el texto
}
}
El ejemplo demuestra un intercambio de datos simple a través de UART . Cuando
PIC MCU recibe datos, los envía inmediatamente. Si el PIC está conectado a la PC
(consulte la figura a continuación), puede probar el ejemplo desde el terminal
mikroC PRO for PIC para la comunicación RS-232, opción de menú Herramientas
›Terminal .
char uart_rd;
void main () {
ANSELH = 0;
UART1_Init (9600); // Inicializar el módulo UART a 9600

bps
Delay_ms (100); // Espera a que el módulo UART se
estabilice
UART1_Write_Text ("Inicio");
UART1_Write (10);
UART1_Write (13);

si (UART1_Data_Ready ()) { // Si se reciben datos,
uart_rd = UART1_Read (); // leer los datos recibidos,
UART1_Write (uart_rd); // y enviar datos a través de UART
}
}
}
Conexión HW
Conexión RS-232 HW
Biblioteca extraíble UART
El módulo de hardware extraíble UART está disponible con estas MCU: 18F2xJ11,
18F4xJ11, 18F2xJ50 y 18F4xJ50. mikroC PRO for PIC UART La biblioteca extraíble
proporciona un trabajo cómodo con el modo asíncrono (dúplex completo).
HW). Luego, simplemente use las funciones enumeradas a continuación.
Importante: Antes de usar esta biblioteca, asegúrese de que la Biblioteca

de selección de pin periférica y la Biblioteca de Uart estén marcadas en
el Administrador de bibliotecas , y de que se hayan asignado los pines
apropiados.
 UART_Remappable_Init
 UART_Remappable_Data_Ready
 UART_Remappable_Tx_Idle
 UART_Remappable_Read
 UART_Remappable_Read_Text
 UART_Remappable_Write
 UART_Remappable_Write_Text
UART_Remappable_Init
Prototipo void UART_Remappable_Init ( const unsigned
long baud_rate);
Devoluciones Nada.
Descripción Inicializa el módulo de hardware UART extraíble con la

velocidad de transmisión deseada. Consulte la hoja de
datos del dispositivo para conocer las velocidades en
baudios permitidas para cada específico Fosc. Si especifica
la velocidad en baudios no admitida, el compilador
informará un error.
Parámetros:
Nota: Antes de usar esta biblioteca, asegúrese de

que la Biblioteca de selección de pin periférico esté
marcada en el Administrador de bibliotecas y de que se
hayan asignado los pines apropiados.

Requiere Necesitará PIC MCU con módulo UART de hardware y

función removible.
UART_Remappable_Initdebe llamarse antes de usar otras
funciones de la Biblioteca removible de UART .

biblioteca.
Ejemplo Esto inicializará el módulo UART de hardware y establecerá

la comunicación a 2400 bps :
UART_Remappable_Init (2400);
UART_Remappable_Data_Ready
Prototipo UART_Remappable_Data_Ready () sin firmar ;
Devoluciones La función devuelve 1 si los datos están listos o 0 si no hay

datos.
Descripción La función prueba si los datos en el búfer de recepción
están listos para su lectura.
Requiere MCU con el módulo UART y característica extraíble.

El módulo UART debe inicializarse antes de usar esta
rutina. Ver la rutina UART_Remappable_Init .

léalos : if (UART_Remappable_Data_Ready () == 1) {
receive = UART_Remappable_Read ();
}
UART_Remappable_Tx_Idle
Prototipo char UART_Remappable_Tx_Idle ();



función. Ver UART_Remappable_Init .

if (UART_Remappable_Tx_Idle () == 1) {
UART_Remappable_Write (_data);
}
UART_Remappable_Read
Prototipo sin signo UART_Remappable_Read ();
Devoluciones Byte recibido.
Descripción La función recibe un byte a través de UART . Use

la función UART_Remappable_Data_Ready para
probar si los datos están listos primero.

rutina. Ver UART_Remappable_Init rutina.

léalos : if (UART_Remappable_Data_Ready () == 1) {
receive = UART_Remappable_Read ();
}
UART_Remappable_Read_Text
Prototipo void UART_Remappable_Read_Text ( char *
Output, char * Delimiter, char Intenta);
Devoluciones Nada.

encuentra el delimitador). El parámetro Attemptsdefine el
número de caracteres recibidos en los que Delimiterse
espera la secuencia. Si Attemptsse establece en 255, esta
rutina intentará continuamente detectar


UART_Remappable_Init (4800); // inicializar el
módulo UART
Delay_ms (100);
while (1) {
if (UART_Remappable_Data_Ready () == 1) {// si se
reciben datos
UART_Remappable_Read_Text (salida, "OK", 10); //
lee el texto hasta que se encuentra 'OK'
UART_Remappable_Write (salida); // devuelve el
texto
}
}
UART_Remappable_Write
Prototipo void UART_Remappable_Write (datos cortos
sin firmar_);
Devoluciones Nada.

Parámetros:
 TxData: datos a enviar

rutina. Ver UART_Remappable_Init rutina.

...
UART_Remappable_Write (_data);
UART_Remappable_Write_Text
Prototipo void UART_Remappable_Write_Text ( char *
uart_text);
Devoluciones Nada.
Descripción Envía texto (parámetro uart_text) a través de UART . El

texto debe estar terminado en cero.


UART_Remappable_Init (4800); // inicializar el
módulo UART
Delay_ms (100);
while (1) {
if (UART_Remappable_Data_Ready () == 1) {// si se
reciben datos
UART_Remappable_Read_Text (salida, "OK", 10); //
lee el texto hasta que se encuentra 'OK'
UART_Remappable_Write (salida); // devuelve el
texto
}
}
Biblioteca USB
Universal Serial Bus (USB) ofrece un estándar de bus serie para conectar una
amplia variedad de dispositivos, incluidos computadoras, teléfonos celulares,
consolas de juegos, PDA , etc.
La biblioteca USB contiene rutinas HID que admiten dispositivos de clase HID y
también las rutinas genéricas que se pueden usar con los controladores
especificados por el vendedor.
Clase USB HID
La clase HID consiste principalmente en dispositivos que utilizan los humanos para
controlar el funcionamiento de los sistemas informáticos. Ejemplos típicos
de dispositivos de clase HID incluyen:
 Teclados y dispositivos señaladores, por ejemplo: dispositivos de mouse
estándar, trackballs y joysticks.
 Controles del panel frontal, por ejemplo: mandos, interruptores,
botones y deslizadores.
 Controles que se pueden encontrar en dispositivos como teléfonos,
controles remotos de VCR, juegos o dispositivos de simulación, por
ejemplo: guantes de datos, aceleradores, volantes y pedales del timón.
 Los dispositivos que pueden no requerir la interacción humana pero
proporcionan datos en un formato similar a los dispositivos de
clase HID , por ejemplo, lectores de códigos de barras, termómetros o
voltímetros.
Muchos dispositivos típicos de clase HID incluyen indicadores, pantallas
especializadas, retroalimentación de audio y retroalimentación forzada o táctil. Por
lo tanto, la definición de clase HIDincluye soporte para varios tipos de resultados
dirigidos al usuario final.
Archivo descriptor
Cada proyecto basado en la biblioteca USB debe incluir un archivo fuente de
descriptor que contenga el ID y el nombre del proveedor, el ID y el nombre del
producto, la longitud del informe y otra información relevante. Para crear un
archivo descriptor, use el terminal USB HID integrado de mikroC PRO para PIC
( Herramientas ›Terminal USB HID ). El nombre predeterminado para el archivo
descriptor es USBdsc.c, pero puede cambiarle el nombre.
Importante:
 Las rutinas de la librería USB han sido cambiadas. Tenga esto en cuenta
al migrar proyectos de versiones anteriores del compilador.
 Además, esto se relaciona con el archivo fuente del descriptor, por lo
que es necesario crear un nuevo archivo descriptor para que su
proyecto funcione.
 HID_Enable
 HID_Leer
 HID_Write
 HID_Disable
 USB_Interrupt_Proc
 USB_Polling_Proc
 Gen_Enable
 Gen_Read
 Gen_Write
HID_Enable
Prototipo void HID_Enable ( char * readbuff, char *
writebuff);
Descripción Habilita la comunicación USB HID .
Parámetros  readbuff: Leer Buffer.

 writebuff: Escribe Buffer.
Estos parámetros se utilizan para la comunicación HID.
Devoluciones Nada.
Requiere Nada.
Ejemplo HID_Enable (& readbuff, y writebuff);
Notas Se debe llamar a esta función antes de usar otras rutinas

de la biblioteca USBHID .
HID_Leer
Prototipo char HID_Read ( void );
Descripción Recibe el mensaje del host y lo almacena en el búfer de
lectura.
Devoluciones Si la lectura de los datos ha fallado, la función devuelve 0.

De lo contrario, devuelve el número de caracteres recibidos
del host.
Requiere USB HID debe estar habilitado antes de usar esta

función. Ver HID_Enable .
Ejemplo //
vuelva a intentarlo hasta que tenga éxito while (!
HID_Read ())
;
Notas Ninguna.
HID_Write
Prototipo char HID_Write ( char * writebuff, char len);
Descripción La función envía datos desde Write Buffer writebuffal

host.
Parámetros  writebuff:Write Buffer, el mismo parámetro

que se usó en la
inicialización; ver HID_Enable .
 len: Especifica una longitud de los datos a
transmitir.
Devoluciones Si la transmisión de datos ha fallado, la función devuelve 0.

De lo contrario, devuelve el número de bytes transmitidos.

Ejemplo //
vuelva a intentarlo hasta que tenga éxito while (!
HID_Write (& writebuff, 64))
;
Notas La llamada a la función debe repetirse siempre que los

datos no se envíen correctamente.
HID_Disable
Prototipo void HID_Disable ( void );
Descripción Desactiva la comunicación USB HID .

Devoluciones Nada.

Ejemplo HID_Disable ();
Notas Ninguna.
USB_Interrupt_Proc
Prototipo void USB_Interrupt_Proc ( void );
Descripción Esta rutina se utiliza para dar servicio a varios eventos de

bus USB. Debe llamarse dentro de la rutina de interrupción
de USB.
Devoluciones Nada.
Requiere Nada.
Ejemplo interrupción del vacío () {

USB_Interrupt_Proc ();
}
Notas No use esta función con USB_Polling_Proc , solo se debe

usar una. Para habilitar el servicio a través de la
interrupción, USB_INTERRUPTse debe establecer la constante
(se establece de forma predeterminada en el archivo
descriptor).
USB_Polling_Proc
Prototipo void USB_Polling_Proc ( void );
Descripción Esta rutina se utiliza para dar servicio a varios eventos de

bus USB. Debe ser periódica, preferentemente cada 100
microsegundos.
Devoluciones Nada.
Requiere Nada.

USB_Polling_Proc ();
kk = HID_Read ();
if (kk! = 0) {
para (cnt = 0; cnt <64; cnt ++)
writebuff [cnt] = readbuff [cnt];
HID_Write (& writebuff, 64);
}
}
Notas No utilice estas funciones con USB_Interrupt_Proc . Para

habilitar el servicio mediante sondeo,
la USB_INTERRUPTconstante debe establecerse en 0 (se
encuentra en el archivo descriptor).
Gen_Enable
Prototipo void Gen_Enable ( char * readbuff, char *
writebuff);
Descripción Inicialice el módulo USB de la MCU.
Parámetros  readbuff: Leer Buffer.

 writebuff: Escribe Buffer.
Devoluciones Nada.
Requiere USB debe estar habilitado antes de usar esta

función. Ver Gen_Enable .
Ejemplo Gen_Enable (& readbuff, & writebuff);
Notas Ninguna.
Gen_Read
Prototipo char Gen_Read ( char *
readbuff, char length, char ep);
Descripción Rutina genérica que recibe los datos especificados desde el

punto final especificado.
Parámetros  readbuff: Datos recibidos.

 length: La longitud de los datos que desea
recibir.
 ep: Número de punto extremo en el que desea
recibir los datos.
Devoluciones Devuelve el número de bytes recibidos, de lo contrario 0.

Ejemplo while (Gen_Read (readbuff, 64,1) == 0)

;
Notas Ninguna.
Gen_Write
Prototipo char Gen_Write ( char *
writebuff, char length, char ep);
Descripción Envía los datos especificados al punto final especificado.
Parámetros  writebuff: Los datos que desea enviar.

 length: la longitud de los datos que desea
enviar.
 ep: Número de punto final al que desea enviar
los datos.
Devoluciones Devuelve el número de bytes transmitidos, de lo contrario

0.

Ejemplo while (Gen_Write (writebuff, 64,1) == 0)

;
Notas Ninguna.
Este ejemplo establece la conexión con el terminal HID que está activo en la
PC. Una vez establecida la conexión, el nombre del dispositivo HID aparecerá en la
ventana correspondiente. Después, el software esperará los datos y devolverá los
datos recibidos. Los ejemplos utilizan el USBdsc.carchivo descriptor, que se
encuentra en la misma carpeta y puede ser creado por el terminal HID.
unsigned char readbuff [64] absolute 0x500; // Los buffers deben estar
en USB RAM, consulte la hoja de datos
unsigned char writebuff [64] absolute 0x540;
char cnt;
char kk;
interrupción del vacío () {

USB_Interrupt_Proc (); // El servicio USB se realiza
dentro de la interrupción.
}
void main ( void ) {

ADCON1 | = 0x0F; // Configure todos los puertos
con función analógica como digital
CMCON | = 7; // Desactivar comparadores
HID_Enable (& readbuff, y writebuff); // Habilitar la comunicación

HID
while (1) {
while (! HID_Read ())
;
para (cnt = 0; cnt <64; cnt ++)

writebuff [cnt] = readbuff [cnt];
while (! HID_Write (& writebuff, 64))

;
}
}
Conexión HW
Esquema de conexión USB
Biblioteca ANSI C Ctype

El mikroC PRO para PIC proporciona un conjunto de funciones de
biblioteca ANSI C estándar para pruebas y mapeo de caracteres.
Importante:
 No todas las funciones estándar han sido incluidas.

 Las funciones se han implementado principalmente de acuerdo con
el estándar ANSI C, pero ciertas funciones se han modificado para
facilitar la programación del PIC. Asegúrese de hojear la descripción
antes de usar las funciones estándar de C.
Funciones de la biblioteca
 Isalnum
 isalfa
 iscntrl
 isigigito
 isgraph
 es bajo
 ispunct
 espacio de emisión
 isupper
 isxdigit
 toupper
 reducir
Isalnum
Prototipo Isalnum corto sin signo ( carácter char );
Descripción La función devuelve 1 si characteres alfanumérica (AZ, az,

0-9), de lo contrario devuelve cero.
Ejemplo res = isalnum ('o'); // devuelve 1

res = isalnum ('\ r'); // devuelve 0
isalfa
Prototipo isalpha corta sin signo ( carácter char );
Descripción La función devuelve 1 si characteres alfabética (AZ, az); de

lo contrario, devuelve cero.
Ejemplo res = isalfa ('A'); // devuelve 1

res = isalfa ('1'); // devuelve 0
iscntrl
Prototipo iscntrl corto sin signo ( carácter char );
Descripción La función devuelve 1 si characteres un carácter de control

o eliminación (decimal 0-31 y 127), de lo contrario devuelve
cero.
Ejemplo res = iscntrl ('\ r'); // devuelve 1

res = iscntrl ('o'); // devuelve 0
isigigito
Prototipo un dígito corto sin signo ( carácter de carácter);
Descripción La función devuelve 1 si characteres un dígito (0-9), de lo

contrario devuelve cero.
Ejemplo res = isdigit ('1'); // devuelve 1

res = isdigit ('o'); // devuelve 0
isgraph
Prototipo Isgraph corto sin signo ( carácter char );
Descripción La función devuelve 1 si characteres imprimible, excluyendo

el espacio (decimal 32), de lo contrario devuelve cero.
Ejemplo res = isgraph ('o'); // devuelve 1

res = isgraph (''); // devuelve 0
es bajo
Prototipo int islower ( Char personaje);
Descripción La función devuelve 1 si characteres una letra minúscula

(az), de lo contrario devuelve cero.
Ejemplo res = islower ('0'); // devuelve 1

res = islower ('A'); // devuelve 0
ispunct
Prototipo sin signo corto ispunct ( carácter char );
Descripción La función devuelve 1 si characteres una puntuación

(decimal 32-47, 58-63, 91-96, 123-126), de lo contrario
devuelve cero.
Ejemplo res = ispunct ('.'); // devuelve 1

res = ispunct ('1'); // devuelve 0
espacio de emisión
Prototipo espacio de escritura corto sin firmar ( carácter
de carácter);
Descripción La función devuelve 1 si characteres un espacio en blanco

(espacio, tabulador, CR, HT, VT, NL, FF), de lo contrario
devuelve cero.
Ejemplo res = isspace (''); // devuelve 1

res = isspace ('1'); // devuelve 0
isupper
Prototipo isupper corto sin signo ( carácter char );
Descripción La función devuelve 1 si characteres una letra mayúscula

(AZ); de lo contrario, devuelve cero.
Ejemplo res = isupper ('A'); // devuelve 1

res = isupper ('a'); // devuelve 0
isxdigit
Prototipo isxdigit corto sin signo ( carácter de carácter);
Descripción La función devuelve 1 si characteres un dígito hexadecimal

(0-9, AF, af), de lo contrario devuelve cero.
Ejemplo res = isxdigit ('A'); // devuelve 1

res = isxdigit ('P'); // devuelve 0
toupper
Prototipo toupper corto sin signo ( carácter de carácter);
Descripción Si characteres una letra minúscula (az), la función devuelve

una letra mayúscula. De lo contrario, la función devuelve un
parámetro de entrada sin cambios.
Ejemplo res = toupper ('a'); // devuelve A

res = toupper ('B'); // devuelve B
reducir
Prototipo tolower corto sin firma ( carácter char );
Descripción Si characteres una letra mayúscula (AZ), la función

devuelve una letra minúscula. De lo contrario, la función
devuelve un parámetro de entrada sin cambios.
Ejemplo res = tolower ('A'); // devuelve un

res = tolower ('b'); // devuelve b
Biblioteca de matemáticas ANSI C

biblioteca ANSI C estándar para el manejo matemático de punto flotante.
Importante:

 acos
 como en
 un bronceado
 atan2
 hacer techo
 cos
 aporrear
 exp
 fabs
 piso
 frexp
 ldexp
 Iniciar sesión
 log10
 modf
 pow
 pecado
 sinh
 sqrt
 bronceado
 Tanh
acos
Prototipo doble acos ( doble x);
Descripción La función devuelve el arco coseno del parámetro x; es decir,

el valor cuyo coseno es x. El parámetro de entrada xdebe
estar entre -1 y 1 (inclusive). El valor de retorno está en
radianes, entre 0 y Π (inclusive).
Ejemplo dudas = acos (0.5); // doub = 1.047198
como en
Prototipo doble asin ( doble x);
Descripción La función devuelve el arco seno del parámetro x; es decir,

el valor cuyo seno es x. El parámetro de entrada xdebe estar
entre -1 y 1 (inclusive). El valor de retorno está en radianes,
entre -Π / 2 y Π / 2 (inclusive).
Ejemplo dudas = asin (0.5); // doub = 5.235987e-1
un bronceado
Prototipo doble atan ( doble f);
Descripción La función calcula la tangente del arco del parámetro f; es

decir, el valor cuya tangente es f. El valor de retorno está en
radianes, entre -Π / 2 y Π / 2 (inclusive).
Ejemplo dudas = atan (1.0); // dudas = 7.853982e-1
atan2
Prototipo doble atan2 ( doble y, doble x);
Descripción Esta es la función tangente del arco de dos argumentos. Es

similar a calcular el arco tangente de y/x, excepto que los
signos de ambos argumentos se utilizan para determinar el
cuadrante del resultado y xse permite que sea cero. El valor
de retorno está en radianes, entre -Π y Π (inclusive).
Ejemplo dudas = atan2 (2., 1.); // dudas = 4.636475e-1
hacer techo
Prototipo doble ceil ( doble x);
Descripción La función devuelve el valor del parámetro xredondeado al

siguiente número entero.
Ejemplo dudas = ceil (0.5); // dudas = 1.000000
cos
Prototipo doble cos ( doble f);
Descripción Función devuelve el coseno de fen radianes. El valor de

retorno es de -1 a 1.
Ejemplo dudas = cos (PI / 3.); // dudas = 0.500008
aporrear
Prototipo doble cosh ( doble x);
Descripción La función devuelve el coseno hiperbólico x, definido

matemáticamente como . Si el valor de x es demasiado
grande (si se produce un desbordamiento), la función
falla .(ex+e-x)/2
Ejemplo dudas = cosh (PI / 3.); // dudas = 1.600286
exp
Prototipo doble exp ( doble x);
Descripción La función devuelve el valor de e, la base de los logaritmos

naturales, elevado a la potencia x(es decir, ).ex
Ejemplo dudas = exp (0.5); // dudas = 1.648721
fabs
Prototipo fabs dobles ( doble d);
Descripción La función devuelve el valor absoluto (es decir, positivo)

de d.
Ejemplo dudas = fabs (-1.3); // dudas = 1.3
piso
Prototipo doble suelo ( doble x);
Descripción La función devuelve el valor del parámetro xredondeado

hacia abajo al entero más cercano.
Ejemplo dudas = piso (15.258); // dudas = 15.000000
frexp
Prototipo doble frexp ( valor doble , int * eptr);
Descripción La función divide un valor de punto flotante en una fracción

normalizada y una potencia integral de 2. El valor de retorno
es la fracción normalizada y el exponente entero se
almacena en el objeto señalado por eptr.
ldexp
Prototipo doble ldexp ( valor doble , int newexp);
Descripción La función devuelve el resultado de multiplicar el número de

punto flotante numpor 2 elevado a la potencia n(es decir,
devuelve ).x * 2n
Ejemplo dudas = ldexp (2.5, 2); // duda = 10
Iniciar sesión
Prototipo doble registro ( doble x);
Descripción La función devuelve el logaritmo natural de x(es

decir ).loge(x)
Ejemplo dudas = log (10); // dudas = 2.302585E
log10
Prototipo doble log10 ( doble x);
Descripción La función devuelve el logaritmo base-10 de x(es

decir ).log10(x)
Ejemplo dudas = log10 (100.); // dudas = 2.000000
modf
Prototipo doble modf ( doble val, doble * iptr);
Descripción La función devuelve el componente fraccional firmado

de val, colocando su componente de número entero en la
variable apuntada por iptr.
Ejemplo doub = modf (6.25, & iptr); // dudas = 0.25, iptr =

6.00
pow
Prototipo doble pow ( doble x, doble y);
Descripción La función devuelve el valor de xelevado a la potencia y(es

decir ).xy
Ejemplo dudas = pow (10., 5.); // dudas = 9.999984e + 4
pecado
Prototipo doble pecado ( doble f);
Descripción Función devuelve el seno de fen radianes. El valor de retorno

es de -1 a 1.
Ejemplo dudas = pecado (PI / 2.); // dudas = 1.000000
sinh
Prototipo doble pecado ( doble x);
Descripción La función devuelve el seno hiperbólico x, definido

matemáticamente como . Si el valor de x es demasiado
grande (si se produce un desbordamiento), la función
falla .(ex-e-x)/2
Ejemplo dudas = sinh (PI / 2.); // dudas = 2.301296
sqrt
Prototipo doble cuadrado ( doble x);
Descripción La función devuelve la raíz cuadrada no negativa de x.
Ejemplo dudas = sqrt (10000.); // dudas = 100.0000
bronceado
Prototipo doble bronceado ( doble x);
Descripción Función devuelve la tangente de xen radianes. El valor de

retorno abarca el rango permitido de punto flotante en el
mikroC PRO para PIC.
Ejemplo dudas = bronceado (PI / 4.); // dudas = 0.999998
Tanh
Prototipo doble tanh ( doble x);
Descripción La función devuelve la tangente hiperbólica x, definida

matemáticamente como sinh(x)/cosh(x).
Ejemplo dudas = tanh (-PI / 4.); // dudas = -0.655793
Biblioteca ANSI C Stdlib

biblioteca ANSI C estándar de utilidad general.
Importante:

 abdominales
 atof
 atoi
 atol
 div
 ldiv
 uldiv
 laboratorios
 max
 min
 rand
 srand
 xtoi
abdominales
Prototipo int abs ( int a);
Descripción La función devuelve el valor absoluto (es decir, positivo)
de a.
Ejemplo resultado = abs (-12); // resultado = 12
atof
Prototipo doble atof ( char * s);
Descripción La función convierte la cadena de entrada sen un valor de

precisión doble y devuelve el valor. La cadena de
entrada sdebe ajustarse al formato literal de punto flotante ,
con un espacio en blanco opcional al principio. La cadena se
procesará un carácter a la vez, hasta que la función alcance
un carácter que no reconoce (incluido un carácter nulo).
Ejemplo dudas = atof ("- 1.23"); // dudas = -1.23
atoi
Prototipo int atoi ( char * s);
Descripción La función convierte la cadena de entrada sen un valor

entero y devuelve el valor. La cadena de entrada sdebe
constar exclusivamente de dígitos decimales, con un espacio
en blanco opcional y un signo al principio. La cadena se
Ejemplo resultado = atoi ("32000"); // resultado = 32000
atol
Prototipo atol largo ( char * s);
Descripción La función convierte la cadena de entrada sen un valor

entero largo y devuelve el valor. La cadena de entrada sdebe
constar exclusivamente de dígitos decimales, con un espacio
en blanco opcional y un signo al principio. La cadena se
Ejemplo resultado = atol ("- 32560"); // resultado = -32560
div
Prototipo div_t div ( int número, int denom);
Descripción La función calcula el resultado de la división del
numerador numberpor el denominador denom; la función
devuelve una estructura de tipo que div_tcomprende
cociente ( quot) y resto ( rem), vea Div Structures .
Ejemplo dt = div (1234,100);
ldiv
Prototipo ldiv_t ldiv ( largo número, largo denom);
Descripción La función es similar a la función div , excepto que los

argumentos y los miembros de la estructura del resultado
tienen todos tipo long.
La función calcula el resultado de la división del
devuelve una estructura de tipo que ldiv_tcomprende
Ejemplo dl = ldiv (-123456, 1000);
uldiv
Prototipo uldiv_t uldiv ( número largo sin signo ,
denominación larga sinsigno);
Descripción La función es similar a la función div , excepto que los

argumentos y los miembros de la estructura del resultado
tienen todos tipo unsigned long.
La función calcula el resultado de la división del
devuelve una estructura de tipo que uldiv_tcomprende
Ejemplo dul = uldiv (123456,1000);
laboratorios
Prototipo laboratorios largos ( largo x);
Descripción La función devuelve el valor absoluto (es decir, positivo) del

entero largo x.
Ejemplo resultado = labs (-2147483647);
max
Prototipo int max ( int a, int b);
Descripción La función devuelve mayor de los dos enteros, ay b.
Ejemplo resultado = max (123,67); // función devuelve 123
min
Prototipo int min ( int a, int b);
Descripción La función devuelve el menor de los dos enteros, ay b.
Ejemplo resultado = min (123,67); // función devuelve 67
rand
Prototipo int rand ();
Descripción La función devuelve una secuencia de números

pseudoaleatorios entre 0 y 32767. La función siempre
producirá la misma secuencia de números a menos que se
llame a srand para inicializar el punto de inicio.
Ejemplo mientras (1)

resultado = rand ()
;
srand
Prototipo void srand ( sin signo x);
Descripción La función se usa xcomo punto de partida para que una

nueva secuencia de números pseudoaleatorios sea devuelta
por las llamadas subsiguientes a rand . Esta función no
devuelve ningún valor.
Ejemplo srand (9);
xtoi
Prototipo xtoi sin signo ( char * s);
Descripción La función convierte la cadena de entrada que sconsta de

dígitos hexadecimales en un valor entero. El parámetro de
entrada sdebe constar exclusivamente de dígitos
hexadecimales, con un espacio en blanco opcional y un signo
al principio. La cadena se procesará un carácter a la vez,
hasta que la función alcance un carácter que no reconoce
(incluido un carácter nulo).
Ejemplo resultado = xtoi ("1FF"); // resultado = 511
Div Estructuras
typedef struct divstruct {

int quot;
int rem;
} div_t;
typedef struct ldivstruct {

long quot;
largo rem;
} ldiv_t;
typedef struct uldivstruct {

unsigned long quot;
rem largo sin firmar ;
} uldiv_t;
Biblioteca de cadenas ANSI C

biblioteca ANSI C estándar útiles para manipular cadenas y memoria RAM.
Importante:

 memchr
 memcmp
 memcpy
 memmove
 memset
 strcat
 strchr
 strcmp
 strcpy
 Strlen
 Strncat
 strncpy
 strspn
 strncmp
 strstr
 strcspn
 Strpbrk
 Strrchr
 strtok
memchr
Prototipo void *memchr(void *p, char n, unsigned int v);
Descripción La función localiza la primera aparición de char nen

los vbytes iniciales del área de memoria a partir de la
dirección p. La función devuelve el puntero a esta ubicación
o 0si nno se encontró.
Para el parámetro p, puede usar un valor numérico (literal /
variable / constante) que indique la dirección de la memoria
o un valor sin referencia de un objeto, por
ejemplo &mystringo &PORTB.
Ejemplo char txt [] = "mikroElektronika";

res = memchr (txt, 'e', 16); // el ejemplo localiza la
primera aparición de la letra 'e' en la cadena 'txt'
en los primeros 16 caracteres de la cadena
memcmp
Prototipo int memcmp ( void * s1, void * s2, int n);
Descripción Función compara los primeros ncaracteres de los objetos a la

que apunta s1y s2y devuelve cero si los objetos son iguales,
o devuelve una diferencia entre los primeros caracteres
diferentes (en una evaluación de izquierda a derecha). En
consecuencia, el resultado es mayor que cero si el objeto
señalado por s1es mayor que el objeto señalado por s2y
viceversa.

char txt_sub [] = "mikro;
res = memcmp (txt, txt_sub, 16); // devuelve 69, que

es un código ASCII del primer carácter diferente -
letra 'E'
memcpy
Prototipo void * memcpy ( void * d1, void * s1, int n);
Descripción La función copia los ncaracteres del objeto apuntado

por s1en el objeto apuntado por d1. Si la copia tiene lugar
entre objetos que se superponen, el comportamiento no está
definido. La función devuelve la dirección del objeto
apuntado por d1.

char txt_sub [] = "mikr;
res = memcpy (txt + 4, txt_sub, 4); // la cadena 'txt'

se rellenará con los primeros 4 caracteres de la
cadena 'txt_sub', a partir del cuarto carácter
// rutina devuelve
la dirección del primer carácter rellenado, si las
áreas de memoria de las cadenas no se superponen
memmove
Prototipo void * memmove ( void * to, void * from, int n);
Descripción La función copia los ncaracteres del objeto apuntado

por fromen el objeto apuntado por to. A diferencia
de memcpy , las áreas de
memoria toy from pueden superponerse. La función
devuelve la dirección del objeto apuntado por to.

char txt_sub [] = "mikr;
res = memmove (txt + 7, txt_sub, 4); // la cadena

'txt' se llenará con los primeros 4 caracteres de la
cadena 'txt_sub', comenzando desde el séptimo carácter
// rutina devuelve
la dirección del primer carácter completado (las áreas
de memoria del objeto pueden superponerse)
memset
Prototipo void * memset ( void * p1, carácter char , int n);
Descripción La función copia el valor de characteren cada uno de los

primeros ncaracteres del objeto señalado por p1. La función
devuelve la dirección del objeto apuntado por p1.
memset (txt, 'a', 2); // rutina copiará el carácter

'a' en cada uno de los primeros 'n' caracteres de la
cadena 'txt',
strcat
Prototipo char * strcat ( char * to, char * from);
Descripción La función agrega una copia de la cadena froma la

cadena to, sobrescribiendo el carácter nulo al final
de to. Luego, se agrega un carácter nulo de terminación al
resultado. Si la copia tiene lugar entre objetos que se
superponen, el comportamiento no está definido. toLa
cadena debe tener suficiente espacio para almacenar el
resultado. La función devuelve la dirección del objeto
apuntado por to.
char * res;
txt [3] = 0;
res = strcat (txt, "_test"); // rutina agregará el
'_test' en el lugar del primer carácter nulo,
agregando el carácter nulo que termina al resultado
// rutina devuelve la
dirección de la cadena 'txt'
strchr
Prototipo char * strchr ( char * ptr, char chr);
Descripción La función localiza la primera aparición de caracteres chren

la cadena ptr. La función devuelve un puntero a la primera
aparición de carácter chr, o un puntero nulo si chrno ocurre
en ptr. El carácter nulo de terminación se considera parte de
la cadena.

char * res;
res = strchr (txt, 'E'); // rutina ubicará el carácter

'E' en la cadena 'txt' y devolverá la dirección del
carácter
strcmp
Prototipo int strcmp ( char * s1, char * s2);
Descripción La función compara cadenas s1y s2y devuelve cero si las

cadenas son iguales, o devuelve una diferencia entre los
primeros caracteres diferentes (en una evaluación de
izquierda a derecha). En consecuencia, el resultado es mayor
que cero si s1es mayor que s2y viceversa.
Ejemplo char txt = "mikroElektronika";

char txt_sub = "mikro";
int res;
res = strcmp (txt, txt_sub); // compara las cadenas

'txt' y 'txt_sub' y devuelve devuelve una diferencia
entre los primeros caracteres diferentes, en este caso
69
strcpy
Prototipo char * strcpy ( char * to, char * from);
Descripción La función copia la cadena fromen la cadena to. Si la copia

es exitosa, la función regresa to. Si la copia tiene lugar entre
objetos que se superponen, el comportamiento no está
definido.
char txt_sub = "mikro_test";
int res;
res = strcpy (txt, txt_sub); // copia la cadena

'txt_sub' a 'txt'
Strlen
Prototipo int strlen ( char * s);
Descripción La función devuelve la longitud de la cadena s(el carácter

nulo de terminación no cuenta para la longitud de la
cadena).

resultado int
resultado = strlen (txt); // calcula la longitud de la

cadena 'txt', resultado = 16
Strncat
Prototipo char * strncat ( char * to, char *
from, tamaño int );
Descripción La función no agrega más que sizecaracteres de la

cadena froma to. El carácter inicial de fromsobrescribe el
carácter nulo al final de to. El carácter nulo de terminación
siempre se añade al resultado. La función vuelve to.

resultado * char ;
txt [5] = 0;
resultado = strncat (txt, txt_sub, 4); // la rutina
agrega los primeros 4 caracteres de la cadena
'txt_sub' en el lugar del primer carácter nulo en la
cadena 'txt'
strncpy
Prototipo char * strncpy ( char * to, char *
from, tamaño int );
Descripción La función no copia más que los sizecaracteres de la

cadena froma to. Si la copia tiene lugar entre objetos que se
superponen, el comportamiento no está definido. Si fromes
más corto que los sizecaracteres, tose rellenarán con
caracteres nulos para compensar la diferencia. La función
devuelve la cadena resultante to.

int res;
res = strncpy (txt, txt_sub, 4); // las copias de los
primeros 4 caracteres forman la cadena 'txt_sub' a
'txt'
strspn
Prototipo int strspn ( char * str1, char * str2);
Descripción La función devuelve la longitud del segmento inicial máximo

del str1cual consta completamente de caracteres de str2. El
carácter nulo que termina al final de la cadena no se
compara.

int res;
resultado = strspn (txt, txt_sub); // routne devuelve

4
strncmp
Prototipo int strncmp ( char * s1, char * s2, char len);
Descripción La función lexicográficamente no compara más que

los lencaracteres (los caracteres que siguen al carácter nulo
no se comparan) de la cadena señalada por s1la cadena
señalada por s2. La función devuelve un valor que indica
la relación s1ys2
Valor Significado
<0 s1 "menos que" s2
= 0 s1 "igual a" s2
> 0 s1 "mayor que" s2

int res;
res = strncmp (txt_sub, txt, 3); // compara los

primeros 3 caracteres de la cadena 'txt' con la cadena
'txt_sub' y devuelve una diferencia
strstr
Prototipo char * strstr ( char * s1, char * s2);
Descripción La función localiza la primera aparición de la cadena s2en la

cadena s1(excluyendo el carácter nulo de terminación).
La función devuelve el puntero a la primera aparición
de s2in s1; Si no se encontró una cadena, la función
regresa 0. Si s2es una cadena nula, la función devuelve 0.

char * res;
res = strstr (txt, txt_sub);
strcspn
Prototipo char * strcspn ( char * s1, char * s2);
Descripción La función calcula la longitud del segmento inicial máximo de

la cadena a la que apunta, s1que consta completamente de
caracteres que no están en la cadena a la que apunta s2.
La función devuelve la longitud del segmento inicial.

char * res;
res = strcspn (txt_sub, txt);
Strpbrk
Prototipo char * strpbrk ( char * s1, char * s2);
Descripción La función busca s1la primera aparición de cualquier carácter

de la cadena s2. El carácter nulo de terminación no se
incluye en la búsqueda. La función devuelve el puntero al
carácter correspondiente en s1. Si s1no contiene caracteres
de s2, la función retorna 0.

char * res;
res = strpbrk (txt_sub, txt);
Strrchr
Prototipo char * strrchr ( char * ptr, char chr);
Descripción La función busca en la cadena ptrla última aparición del

carácter chr. La terminación de caracteres nulos ptrno se
incluye en la búsqueda. La función devuelve el puntero al
último chrencontrado en ptr; Si no se encontró ningún
carácter coincidente, la función regresa 0.
res = strrchr (txt_sub, 'k'); // devuelve el puntero

al carácter 'k' de la cadena 'txt'
strtok
Prototipo char * strtok ( char * s1, char * s2);
Devoluciones La función strtok devuelve un puntero al primer carácter de

un token, o un puntero nulo si no hay un token.
Descripción Una secuencia de llamadas a la función strtok divide la
cadena apuntada por s1 en una secuencia de tokens, cada
una de las cuales está delimitada por un carácter de la
cadena apuntada por s2. La primera llamada en la
secuencia tiene s1 como su primer argumento, y es
seguida por llamadas con un puntero nulo como su primer
argumento. La cadena de separación a la que apunta s2
puede ser diferente de una llamada a otra.
La primera llamada en la secuencia busca en la cadena a la
que apunta s1 el primer carácter que no está contenido en
la cadena de separación actual a la que apunta s2. Si no se
encuentra tal carácter, entonces no hay tokens en la
cadena apuntada por s1 y la función strtok devuelve un
puntero nulo. Si se encuentra dicho carácter, es el
comienzo del primer token.
La función strtok luego busca desde allí un carácter que
está contenido en la cadena de separación actual. Si no se
encuentra dicho carácter, el token actual se extiende hasta
el final de la cadena apuntada por s1, y las búsquedas
subsiguientes de un token devolverán un puntero nulo. Si
se encuentra tal carácter, se sobrescribe con un carácter
nulo, que termina el token actual. La función strtok guarda
un puntero al siguiente carácter, desde el cual comenzará
la próxima búsqueda de un token.
Cada llamada subsiguiente, con un puntero nulo como
valor del primer argumento, comienza a buscar desde el
puntero guardado y se comporta como se describe
anteriormente.
Ejemplo char x [10];
void main () {
strcpy (x, strtok ("mikroEl", "Ek"));

strcpy (x, strtok (0, "kE"));
Biblioteca de botones
La biblioteca de botones proporciona rutinas para la detección de pulsaciones de
botones y el rebote (eliminando la influencia del parpadeo de contacto al presionar
un botón).
 Botón
Botón
Prototipo Botón corto
sin firmar ( puerto corto * sin firmar , pin corto
sin firmar , tiempo corto
sin firmar , active_state corto sin firmar);
Devoluciones  255 si el pin estaba en el estado activo para un

período determinado.
Descripción La función elimina la influencia del parpadeo del contacto al
presionar un botón (rebote).
El parámetro portespecifica la ubicación del
botón; parámetro pines el número de pin en
designado porty va desde 0..7; parámetro timees un
período de rebote en milisegundos; el
parámetro active_statepuede ser 0 o 1, y determina si el
botón está activo con cero lógico o lógico.
Requiere El pin del botón debe estar configurado como entrada.
Ejemplo El ejemplo lee RB0, al que está conectado el botón; En la

transición de 1 a 0 (liberación del botón), PORTD se
invierte:
poco viejo estado
// Bandera del estado antiguo
void main () {
ANSEL = 0; //
Configurar pines AN como E / S digital
ANSELH = 0;
C1ON_bit = 0; //
Desactivar comparadores
C2ON_bit = 0;
TRISB0_bit = 1; //
establece el pin RB0 como entrada
TRISC = 0x00; //
Configurar PORTC como salida
PORTC = 0xAA; //
Valor PORTC inicial
antiguo estado = 0;
do {
if (Button (& PORTB, 0, 1, 1)) {
// Detectar lógico
onestate = 1; //
indicador de actualización
}
if (oldstate && Button (& PORTB, 0, 1, 0)) {
// Detectar la transición de uno a cero
PORTC = ~ PORTC; //
Invertir PORTC
oldstate = 0; //
indicador de actualización
}
} while (1); //
Bucle sin fin
}
Biblioteca de conversiones
La biblioteca mikroC PRO for PIC Conversions proporciona rutinas para números a
cadenas y conversiones BCD / decimales.
Puede obtener una representación de texto de valor numérico pasándolo a una de
las siguientes rutinas:
 ByteToStr
 ShortToStr
 WordToStr
 IntToStr
 LongToStr
 LongWordToStr
 FloatToStr
 WordToStrWithZeros
 IntToStrWithZeros
 LongWordToStrWithZeros
 LongIntToStrWithZeros
 ByteToHex
 ShortToHex
 WordToHex
 IntToHex
 LongWordToHex
 LongIntToHex
 Rtrim
 Ltrim
Las siguientes funciones convierten los valores decimales en BCD y viceversa:
 Dec2Bcd
 Bcd2dec
 Dec2Bcd16
 Bcd2dec16
ByteToStr
Prototipo void ByteToStr ( entrada corta sin
signo , salida char *);
Devoluciones Nada.
Descripción Convierte el byte de entrada en una cadena. La cadena de

salida tiene un ancho fijo de 4 caracteres, incluido un
carácter nulo al final (terminación de cadena). La cadena
de salida está justificada a la derecha y las posiciones
restantes a la izquierda (si las hay) se rellenan con
espacios en blanco.
Parámetros:
 input: byte a convertir
 output: cadena de destino
Requiere La cadena de destino debe tener al menos 4 caracteres de

longitud.
Ejemplo corto sin signo t = 24;

char txt [4];
...
ByteToStr (t, txt); // txt es "24" (un espacio en
blanco aquí)
ShortToStr
Prototipo void ShortToStr ( entrada corta , salida char *);
Devoluciones Nada.
Descripción Convierte un número corto firmado en una cadena. La

cadena de salida tiene un ancho fijo de 5 caracteres,
incluido un carácter nulo al final (terminación de
cadena). La cadena de salida está justificada a la derecha y
las posiciones restantes a la izquierda (si las hay) se
rellenan con espacios en blanco.
Parámetros:
 input: Número corto firmado para convertir

longitud.
Ejemplo t corto = -24;

char txt [5];
...
ShortToStr (t, txt); // txt es "-24" (un espacio en
blanco aquí)
WordToStr
Prototipo void WordToStr ( entrada sin
firmar , salida char *);
Devoluciones Nada.
Descripción Convierte la palabra de entrada en una cadena. La cadena

de salida tiene un ancho fijo de 6 caracteres, incluido un
restantes a la izquierda (si las hay) se rellenan con
espacios en blanco.
Parámetros:
 input: palabra para ser convertido

longitud.
Ejemplo sin signo t = 437;

char txt [6];
...
WordToStr (t, txt); // txt es "437" (dos espacios
en blanco aquí)
IntToStr
Prototipo void IntToStr ( int input, char * output);
Devoluciones Nada.
Descripción Convierte el número entero con signo de entrada en una

cadena. La cadena de salida tiene un ancho fijo de 7
caracteres, incluido un carácter nulo al final (terminación
de cadena). La cadena de salida está justificada a la
derecha y las posiciones restantes a la izquierda (si las
hay) se rellenan con espacios en blanco.
Parámetros:
 input: número entero con signo para convertir

longitud.
Ejemplo int j = -4220;

char txt [7];
...
IntToStr (j, txt); // txt es "-4220" (un espacio en
blanco aquí)
LongToStr
Prototipo void LongToStr ( entrada larga , salida char *);
Devoluciones Nada.
Descripción Convierte un número entero largo con signo de entrada en

una cadena. La cadena de salida tiene un ancho fijo de 12
Parámetros:
 input: Número entero largo con signo para
convertir

longitud.
Ejemplo jj largo = -3700000;

char txt [12];
...
LongToStr (jj, txt);
// txt es "-3700000" (tres espacios en blanco aquí)
LongWordToStr
Prototipo void LongWordToStr ( entrada larga sin
Devoluciones Nada.
Descripción Convierte un número entero largo sin firmar de entrada en
Parámetros:
 input: Número entero largo sin firmar para
convertir

longitud.
Ejemplo sin firmar largo jj = 3700000;

char txt [11];
...
LongWordToStr (jj, txt);
// txt es "3700000" (tres espacios en blanco aquí)
FloatToStr
Prototipo unsigned char FloatToStr ( float fnum, unsigned
char * str);
Devoluciones  3 si el número de entrada es NaN

 2 si el número de entrada es -INF
 1 si el número de entrada es + INF
 0 si la conversión fue exitosa
Descripción Convierte un número de punto flotante en una cadena.

Parámetros:
 fnum: Número de punto flotante a convertir
 str: cadena de destino
La cadena de salida se justifica a la izquierda y se termina
en nulo después del último dígito.
Nota: el número de punto flotante dado se truncará

a los 7 dígitos más significativos antes de la conversión.

longitud.
Ejemplo float ff1 = -374.2;

float ff2 = 123.456789;
float ff3 = 0.000001234;
char txt [15];
...
FloatToStr (ff1, txt); // txt es "-374.2"
FloatToStr (ff2, txt); // txt es "123.4567"
FloatToStr (ff3, txt); // txt es "1.234e-6"
WordToStrWithZeros
Prototipo void WordToStrWithZeros ( entrada int sin
Devoluciones Nada.
Descripción Convierte la palabra de entrada en una cadena. La cadena

restantes a la izquierda (si las hay) se rellenan con ceros.
Parámetros:
 input: entero sin signo para convertir

longitud.

char txt [6];
...
WordToStrWithZeros (t, txt); // txt es "0437" (un
cero aquí)
IntToStrWithZeros
Prototipo void IntToStrWithZeros ( int input, char *
output);
Devoluciones Nada.
Descripción Convierte un entero de entrada en una cadena. La cadena

restantes a la izquierda (si las hay) se rellenan con ceros.
Parámetros:
 input: número entero a convertir

longitud.

char txt [7];
...
IntToStrWithZeros (t, txt); // txt es "-03276" (un
cero aquí)
LongWordToStrWithZeros
Prototipo void LongWordToStrWithZeros ( entrada larga sin
Devoluciones Nada.
Descripción Convierte la palabra larga de entrada en una cadena. La
incluido un carácter nulo al final (terminación de
cadena). La cadena de salida está justificada a la derecha y
las posiciones restantes a la izquierda (si las hay) se
rellenan con ceros.
Parámetros:
 input: Número largo sin firmar para convertir

longitud.
Ejemplo sin firma t = 12345678;

char txt [11];
...
LongWordToStrWithZeros (t, txt); // txt es
"0012345678" (dos ceros)
LongIntToStrWithZeros
Prototipo void LongIntToStrWithZeros
( entrada larga , salida char *);
Devoluciones Nada.
Descripción Convierte un número entero largo con signo de entrada en

hay) se rellenan con zaeros.
Parámetros:
 input: Número largo firmado para ser
convertido

longitud.

char txt [12];
...
LongIntToStrWithZeros (j, txt); // txt es "-
0012345678" (un cero aquí)
ByteToHex
Prototipo void ByteToHex ( Char de entrada, Char * salida);
Devoluciones Nada.
Descripción Convierte el número de entrada en una cadena que

contiene la representación hexadecimal del número. La
incluido un carácter nulo al final (terminación de cadena).
Parámetros:
 input: byte a convertir

longitud.

char txt [3];
...
ByteToHex (t, txt); // txt es "02"
ShortToHex
Prototipo void ShortToHex ( entrada corta sin
Devoluciones Nada.

Parámetros:
 input: Número corto firmado para convertir

longitud.

char txt [3];
...
ShortToHex (t, txt); // txt es "9C"
WordToHex
Prototipo void WordToHex ( entrada sin
Devoluciones Nada.

Parámetros:
 input: entero sin signo para convertir

longitud.
Ejemplo sin firma t = 1111;
char txt [5];
...
WordToHex (t, txt); // txt es "0457"
IntToHex
Prototipo void IntToHex ( int input, char * output);
Devoluciones Nada.

Parámetros:
 input: número entero con signo para convertir

longitud.

char txt [5];
...
IntToHex (j, txt); // txt es "8000"
LongWordToHex
Prototipo void LongWordToHex ( entrada larga sin
Devoluciones Nada.

Parámetros:
 input: Número entero largo sin firmar para
convertir

longitud.
Ejemplo sin firmar largo jj = 65535;

char txt [9];
...
LongWordToHex (jj, txt); // txt es "0000FFFF"
LongIntToHex
Prototipo void LongIntToHex ( entrada int
larga , salida char *);
Devoluciones Nada.

Parámetros:
 input: Número entero largo con signo para
convertir

longitud.
Ejemplo long int jj = -2147483648;

char txt [9];
...
LongIntToHex (jj, txt); // txt es "80000000"
Dec2Bcd
Prototipo Dec2Bcd corto sin firmar (decnum corto
sin firmar );
Devoluciones Valor BCD convertido .
Descripción Convierte el número entero corto sin signo de entrada en

su representación BCD apropiada .
Parámetros:
 decnum: número entero corto sin firmar para
convertir
Requiere Nada.
Ejemplo corto sin firmar a, b;

...
a = 22;
b = Dec2Bcd (a); // b es igual a 34
Bcd2dec
Prototipo Bcd2Dec corto sin firmar (decnum corto
sin firmar );
Devoluciones Valor decimal convertido.
Descripción Convierte el número BCD de 8 bits a su equivalente

decimal.
Parámetros:
 bcdnum:Número de BCD de 8 bits a convertir
Requiere Nada.
Ejemplo corto sin firmar a, b;

...
a = 0x34; // a es igual a 0x34
b = Bcd2Dec (a); // b es igual a 22
Dec2Bcd16
Prototipo sin firmar Dec2Bcd16 ( decreto sin firmar);
Devoluciones Valor BCD convertido .
Descripción Convierte un valor decimal sin signo de 16 bits a

su equivalente BCD .
Parámetros:
 decnum Número decimal de 16 bits sin firmar
para convertir
Requiere Nada.
Ejemplo sin firmar a, b;

...
a = 2345;
b = Dec2Bcd16 (a); // b es igual a 9029
Bcd2dec16
Prototipo Bcd2Dec16 sin firmar ( bcdnum sin firmar);
Devoluciones Valor decimal convertido.
Descripción Convierte el número BCD de 16 bits a su equivalente

decimal.
Parámetros:
 bcdnum:Número de BCD de 16 bits para
convertir
Requiere Nada.
Ejemplo sin firmar a, b;

...
a = 0x1234; // a es igual a 4660
b = Bcd2Dec16 (a); // b es igual a 1234
Rtrim
Prototipo char * Rtrim ( char * string);
Devoluciones La función devuelve el puntero a la matriz sin espacios
finales.
Descripción Recorta los espacios finales de la matriz dada con *string

Parámetros:
 string: matriz a recortar.
Requiere Nada.
Ejemplo char * res;
res = Rtrim ("mikroe"); // recorta los espacios

finales y devuelve la dirección del primer carácter
sin espacio
Ltrim
Prototipo char * Ltrim ( char * string);
Devoluciones La función devuelve el puntero a la matriz sin espacios

iniciales.
Descripción Recorta los espacios iniciales de la matriz dada con

*string
Parámetros:
 string: matriz a recortar.
Requiere Nada.
Ejemplo char * res;
res = Ltrim ("mikroe"); // recorta los espacios

iniciales y devuelve la dirección del primer
carácter sin espacio
Biblioteca de PrintOut
El mikroC PRO para PIC proporciona la rutina PrintOut para un fácil formateo e
impresión de datos.
Importante: la biblioteca trabaja solo con la familia PIC18.
 Imprimir
Imprimir
Prototipo void PrintOut ( void (* prntoutfunc)
( char ch), const char * f, ...);
Devolucione Nada.
s
Descripción PrintOut se utiliza para formatear datos e imprimirlos de

una manera definida por el usuario a través de una función
de controlador de impresión.
Parámetros:
 prntoutfunc: función de controlador de
impresión
 f: cadena de formato
El fargumento es una cadena de formato y puede estar
compuesto de caracteres, secuencias de escape y
especificaciones de formato. Los caracteres ordinarios y las
secuencias de escape se copian en el controlador de
impresión en el orden en que se interpretan. Las
especificaciones de formato siempre comienzan con un
signo de porcentaje ( %) y requieren que se incluyan
argumentos adicionales en la llamada a la función.
La cadena de formato se lee de izquierda a derecha. La
primera especificación de formato encontrada se refiere al
primer argumento después del fparámetro y luego lo
convierte y lo genera utilizando la especificación de
formato. La segunda especificación de formato accede al
segundo argumento posterior f, y así sucesivamente. Si
hay más argumentos que especificaciones de formato, los
argumentos adicionales se ignoran. Los resultados son
impredecibles si no hay suficientes argumentos para las
especificaciones de formato. Las especificaciones de
formato tienen el siguiente formato:
% [ banderas ] [ ancho ] [. precisión ] [{l | L}]
tipo de conversión
Cada campo en la especificación de formato puede ser un
solo carácter o un número que especifica una opción de
formato particular. El conversion_typecampo es donde un
solo carácter especifica que un argumento se interpreta
como un carácter, cadena, número o puntero, como se
muestra en la siguiente tabla:
conversion_typ
Tipo de argumento Formato de salida
e
Número decimal
d int
firmado
unsigned in Número decimal sin

u
t firmar
unsigned in Número octal sin

o
t firmar
Número
unsigned in hexadecimal sin
x
t firmar utilizando
0123456789abcdef
Número
hexadecimal sin
unsigned in
X signo utilizando
t
0123456789ABCED
F
Número de punto
flotante con el
f double
formato [-]
dddd.dddd
Número de punto
flotante con el
e double
formato [-] d.dddde
[-] dd
Número de punto
flotante con el
E double
formato [-] d.ddddE
[-] dd
Número de punto
flotante con el
formato e o f, el
g double que sea más
compacto para el
valor y la precisión
especificados
intse convierte
en un unsigned
c int char, y el
carácter resultante
se escribe
Cadena con un
s char * carácter nulo de
terminación
Valor del puntero,

p void * se utiliza el formato
X
Se escribe un%. No
se convierte ningún
argumento. La
% <none>
especificación de
conversión
completa será %%.
El flagscampo es donde se usa un solo carácter para

justificar la salida e imprimir signos y espacios en blanco,
decimales y prefijos octal y hexadecimales, como se
muestra en la siguiente tabla.
flags Sentido
A la izquierda justifica la salida en el ancho de campo

-
especificado.
Prefije el valor de salida con el signo + o - si la salida es un

+
tipo firmado.
Prefije el valor de salida con un espacio en blanco si es un

space
valor positivo firmado.De lo contrario, no hay prefijo en
(' ') blanco.
Prefijo un valor distinto de cero de salida

con 0, 0xo 0Xcuando se usa con o, xyXlos tipos de
campo, respectivamente. Cuando se utiliza con
#
los e, E, f, g, yGtipos de campos, la #bandera obliga al
valor de salida para incluir un punto decimal. En cualquier
otro caso #se ignora la bandera.
* Ignorar el especificador de formato.
El widthcampo es un número no negativo que especifica un

número mínimo de caracteres impresos. Si un número de
caracteres en el valor de salida es menor que el ancho, los
espacios en blanco se agregan a la izquierda o a la derecha
(cuando se especifica la bandera -) para rellenar el ancho
mínimo. Si el ancho tiene el prefijo 0, los ceros se rellenan
en lugar de los espacios en blanco. El widthcampo nunca
trunca un campo. Si la longitud del valor de salida excede
el ancho especificado, se emitirán todos los caracteres.
El precisioncampo es un número no negativo que
especifica el número de caracteres a imprimir, el número
de dígitos significativos o el número de decimales. El
campo de precisión puede causar el truncamiento o el
redondeo del valor de salida en el caso de un número de
punto flotante como se especifica en la siguiente tabla.
flags Significado del precisioncampo
El campo de precisión es donde se especifica el número

mínimo de dígitos que se incluirán en el valor de
salida. Los dígitos no se truncan si el número de dígitos en
d, u, o,
un argumento supera el definido en el campo de
x, X
precisión. Si el número de dígitos en el argumento es
menor que el campo de precisión, el valor de salida se
rellena a la izquierda con ceros.

f de dígitos a la derecha del punto decimal. El último dígito
se redondea.

e, E de dígitos a la derecha del punto decimal. El último dígito
se redondea.

g
máximo de dígitos significativos en el valor de salida.
El campo de precisión no tiene efecto en estos tipos de

c, C
campo.

s máximo de caracteres en el valor de salida. El exceso de
caracteres no se imprime.
Los caracteres opcionales lo Lpueden preceder

inmediatamente conversion_typepara especificar
respectivamente versiones largas de los tipos de
enteros d, i, u, o, x, y X.
Debe asegurarse de que el tipo de argumento coincida con
el de la especificación de formato. Puede usar conversiones
de tipo para asegurarse de que se pasa el tipo
correcto printout.
Requiere Nada.
Ejemplo Imprima el archivo de encabezado del ejemplo de

mikroElektronika en UART.
void PrintHandler ( char c) {
UART1_Write (c);
}
void main () {
UART1_Init (9600);
Delay_ms (100);
PrintOut (PrintHandler, " / * rn"

"* Nombre del proyecto: rn"
"PrintOutExample (uso de
muestra de la función PrintOut ()) rn"
"* Copyright: rn"
"(c) MikroElektronika,
2006.rn"
"* Historial de revisiones:
rn"
"20060710: rn"
"- Liberación inicial"
"* Descripción: rn"
"Demostración simple sobre
el uso de la función PrintOut ()"
"* Configuración de prueba:
rn"
"MCU: PIC18F4520rn"
"Dev.Board: EasyPIC6rn"
"Oscilador: HS,% 6.3fMHzrn"
"Módulos Ext.: Ninguno.rn"
"SW: mikroC PRO for PICrn"
"* NOTAS: rn"
"Ninguno.rn"
"* / rn", Get_Fosc_kHz () /
1000.);
Biblioteca de Setjmp
Esta biblioteca contiene definiciones de funciones y tipos para omitir la llamada de
función normal y la disciplina de devolución. El tipo declarado es jmp_buf, que es
un tipo de matriz adecuado para mantener la información necesaria para restaurar
un entorno de llamada.
La declaración de tipo está contenida en los archivos de cabecera sejmp16.h y
setjmp18.h para las mcus de las familias PIC16 y PIC18, respectivamente. Estos
encabezados se pueden encontrar en la carpeta de inclusión del compilador. La
implementación de esta biblioteca es diferente para los mcus de las familias PIC16
y PIC18. Para la familia PIC16, Setjmp y Longjmp se implementan como macros
definidas en el archivo de encabezado setjmp16.h y para la familia PIC18 como
funciones definidas en el archivo de biblioteca setjmp.
Nota: debido a la familia PIC16 específica de no poder leer / escribir el

puntero de la pila, la ejecución del programa después de que ocurra la asignación
de Longjmp depende del contenido de la pila. Es por eso que, solo para la familia
PIC16, la implementación de las funciones Setjmp y Longjmp no cumple con el
estándar ANSI C.
 Setjmp
 Longjmp
Setjmp
Prototipo int setjmp ( jmp_buf env);
Devoluciones si la devolución es de invocación directa, devuelve 0

si la devolución es de una llamada a longjmp devuelve un
valor distinto de cero
Descripción Esta función guarda la posición de llamada en jmp_buf
para su uso posterior por longjmp. El parámetro env:
matriz de tipo (jmp_buf) adecuado para mantener la
información necesaria para restaurar el entorno de
llamada.
Requiere Nada.
Ejemplo setjmp (buf);
Longjmp
Prototipo void longjmp ( jmp_buf env, int val);
Devoluciones longjmp hace que setjmp devuelva val, si val es 0

devolverá 1.
Descripción Restaura el entorno de llamada guardado en jmp_buf

mediante la invocación más reciente de la macro setjmp. Si
no ha habido tal invocación, o la función relacionada con la
invocación de setjmp ha terminado en el ínterin, el
comportamiento es indefinido env. Parámetro: matriz de
tipo (jmp_buf) que contiene la información guardada por la
correspondiente invocación de setjmp, valvalor char, que
devolverá setjmp correspondiente.
Requiere La invocación de Longjmp debe ocurrir antes de regresar

de la función en la cual Setjmp fue llamado encuentros.
Ejemplo longjmp (buf, 2);
El ejemplo muestra la función de llamada cruzada usando las funciones setjmp y
longjmp. Cuando se llama, Setjmp () guarda su entorno de llamada en su
argumento jmp_buf para su uso posterior por el Longjmp (). Longjmp (), por otro
lado, restaura el entorno guardado por la invocación más reciente de Setjmp () con
el argumento jmp_buf correspondiente. El ejemplo dado es para P16.
#include <setjmp16.h>
jmp_buf buf; // Nota: los diagramas de flujo del programa se

indexan de acuerdo con
// la secuencia de ejecución
void func33 () { // 2 <---------- |

Delay_ms (1000); // |
// |
asm nop; // |
longjmp (buf, 2); // 3 --------------> |
asm nop; // | |
// | |
} // | |
// | |
void func () { // 1 <------ | | |
// | | |
PORTB = 3; // | | |
if (setjmp (buf) == 2) // 3 <-------------- |
PORTB = 1; // 4 -> | | |
else // | | |
func33 (); // 2 ----------> |
// | |
asm nop; // 4 <- | |
} // 5 ------- | -------> depende del contenido de
la pila
// |
void main () { // |
// |
PORTB = 0; // |
TRISB = 0; // |
// |
asm nop; // |
// |
func (); // 1 ------> |
//
asm nop; //
Delay_ms (1000);
PORTB = 0xFF;
}
Biblioteca Sprint
El mikroC PRO para PIC proporciona la función estándar ANSI C Sprintf para
facilitar el formateo de datos.
Nota: Además del estándar ANSI C, la Biblioteca Sprint también incluye dos
versiones limitadas de la sprintffunción ( sprintiy sprintl)
Estas funciones requieren menos ROM y RAM y pueden ser más convenientes
para el uso en algunos casos.
Funciones
 sprintf
 sprintl
 sprinti
sprintf
Prototipo void sprintf ( char * wh, const code char * f,
...);
Devolucione La función devuelve el número de caracteres realmente

s escritos en la cadena de destino.
Descripción sprintf se utiliza para formatear datos e imprimirlos en la

cadena de destino.
Parámetros:
 wh: cadena de destino
 f: cadena de formato
El fargumento es una cadena de formato y puede estar
compuesto de caracteres, secuencias de escape y
especificaciones de formato. Los caracteres ordinarios y las
secuencias de escape se copian en la cadena de destino en
el orden en que se interpretan. Las especificaciones de
formato siempre comienzan con un signo de porcentaje ( %)
y requieren que se incluyan argumentos adicionales en la
llamada a la función.
La cadena de formato se lee de izquierda a derecha. La
primera especificación de formato encontrada se refiere al
primer argumento posterior fy luego lo convierte y lo
genera utilizando la especificación de formato. La segunda
especificación de formato accede al segundo argumento
posterior f, y así sucesivamente. Si hay más argumentos
que especificaciones de formato, estos argumentos
adicionales se ignoran. Los resultados son impredecibles si
no hay suficientes argumentos para las especificaciones de
formato. Las especificaciones de formato tienen el siguiente
formato:
% [ banderas ] [ ancho ] [. precisión ] [{l | L}]
tipo de conversión
Cada campo en la especificación de formato puede ser un
solo carácter o un número que especifica una opción de
formato particular. El conversion_typecampo es donde un
solo carácter especifica que el argumento se interpreta
como un carácter, cadena, número o puntero, como se
muestra en la siguiente tabla:
conversion_typ
Tipo de argumento Formato de salida
e
Número decimal
d int
firmado
unsigned in Número decimal sin

u
t firmar
unsigned in Número octal sin

o
t firmar
Número
unsigned in hexadecimal sin
x
t firmar utilizando
0123456789abcdef
Número
hexadecimal sin
unsigned in
X signo utilizando
t
0123456789ABCED
F
Número de punto
flotante con el
f double
formato [-]
dddd.dddd
Número de punto
flotante con el
e double
formato [-] d.dddde
[-] dd
Número de punto
flotante con el
E double
formato [-] d.ddddE
[-] dd
Número de punto
flotante con el
formato e o f, el
g double que sea más
compacto para el
valor y la precisión
especificados
intse convierte
a unsigned
c int char, y el
carácter resultante
se escribe
Cadena con un
s char * carácter nulo de
terminación
Valor del puntero,

p void * se utiliza el formato
X
Se escribe un%. No
se convierte ningún
argumento. La
% <none>
especificación de
conversión
completa será %%.
El flagscampo es donde se usa un solo carácter para

justificar la salida e imprimir signos y espacios en blanco,
decimales y prefijos octal y hexadecimales, como se
muestra en la siguiente tabla.
flags Sentido
A la izquierda justifica la salida en el ancho de campo

-
especificado.
Prefije el valor de salida con el signo + o - si la salida es un

+
tipo firmado.
Prefije el valor de salida con un espacio en blanco si es un

space
valor positivo firmado. De lo contrario, no hay prefijo en
(' ') blanco
Prefijos un valor de salida no nulo con 0, 0xo 0Xcuando

se usa con o, xy Xlos tipos de campo,
respectivamente. Cuando se utiliza con e, E, f, g,
#
y Gtipos de campos, la #bandera obliga al valor de salida
para incluir un punto decimal. La bandera # se ignora en
todos los demás casos.
* Ignorar el especificador de formato.
El widthcampo es un número no negativo que especifica el

número mínimo de caracteres impresos. Si un número de
caracteres en el valor de salida es menor que el ancho,
entonces se agregan espacios en blanco a la izquierda o a
la derecha (cuando se especifica la bandera -) para rellenar
hasta el ancho mínimo. Si el ancho tiene el prefijo 0, los
ceros se rellenan en lugar de los espacios en
blanco. El widthcampo nunca trunca un campo. Si una
longitud del valor de salida excede el ancho especificado,
se emitirán todos los caracteres.
El precisioncampo es un número no negativo que
especifica un número de caracteres para imprimir, número
de dígitos significativos o número de lugares decimales. El
campo de precisión puede causar el truncamiento o el
redondeo del valor de salida en el caso de un número de
punto flotante como se especifica en la siguiente tabla.
flags Significado del precisioncampo
El campo de precisión es donde se especifica un número

mínimo de dígitos que se incluirán en el valor de
salida. Los dígitos no se truncan si el número de dígitos en
d, u, o,
el argumento supera el definido en el campo de
x, X
precisión. Si un número de dígitos en el argumento es
menor que el campo de precisión, el valor de salida se
rellena a la izquierda con ceros.
f de dígitos a la derecha del punto decimal. El último dígito
se redondea.

e, E de dígitos a la derecha del punto decimal. El último dígito
se redondea.

g
máximo de dígitos significativos en el valor de salida.
El campo de precisión no tiene efecto en estos tipos de

c, C
campo.

s máximo de caracteres en el valor de salida. El exceso de
caracteres no se imprime.
Los caracteres opcionales lo Lpueden preceder

inmediatamente conversion_typepara especificar
respectivamente versiones largas de los tipos de
enteros d, i, u, o, x, y X.
Debe asegurarse de que el tipo de argumento coincida con
el de la especificación de formato. Puede usar conversiones
de tipo para asegurarse de que se pasa el tipo
correcto sprintf.
sprintl
Prototipo void sprintl ( char * wh, const code char * f,
...);
Devoluciones La función devuelve el número de caracteres realmente

escritos en la cadena de destino.
Descripción Lo mismo que sprintf, excepto que no admite números de

tipo flotante.
sprinti
Prototipo void sprinti ( char * wh, const code char * f,
...);
Devoluciones La función devuelve el número de caracteres realmente

escritos en la cadena de destino.
Descripción Lo mismo que sprintf, excepto que no admite enteros

largos y números de tipo flotante.
Esta es una demostración del uso estándar de la rutina de la biblioteca C
sprintf. Tres representaciones diferentes del mismo número de poing flotante
obtenidas mediante el uso de la rutina sprintf se envían a través de UART.
doble ww = -1.2587538e + 1;
void main () {
UART1_Init (4800); // Inicializar módulo UART a

4800 bps
Delay_ms (10);
UART1_Write_Text ("representación de número de punto flotante"); //

Escribir mensaje en UART
sprintf (búfer, "% 12e", ww); // Formatear ww y almacenarlo

en el búfer
UART1_Write_Text ("rne format:"); // Escribir mensaje en UART
UART1_Write_Text (buffer); // Escribe buffer en UART
sprintf (búfer, "% 12f", ww); // Formatea ww y

guárdalo en el buffer UART1_Write_Text ("rnf format:"); //
Escribir mensaje en UART
sprintf (tampón, "% 12g", ww); // Formatear ww y almacenarlo

en el buffer
UART1_Write_Text ("rng format:"); // Escribir mensaje en UART
}
Biblioteca de tiempo
La biblioteca de tiempo contiene funciones y definiciones de tipo para los cálculos
de tiempo en el formato de tiempo UNIX que cuenta el número de segundos desde
la "época". Esto es muy conveniente para los programas que trabajan con
intervalos de tiempo: la diferencia entre dos valores de tiempo UNIX es una
diferencia de tiempo real medida en segundos.
¿Cuál es la época?
Originalmente se definió como el principio de 1970 GMT. (1 de enero de 1970, día
de Julian) GMT, Greenwich Mean Time, es un término tradicional para la zona
horaria de Inglaterra.
El tipo TimeStruct es un tipo de estructura adecuado para el almacenamiento de
fecha y hora. La declaración de tipo __Time.hse encuentra en la carpeta de ejemplo
de demostración de la biblioteca de tiempo de mikroC PRO for PIC.
 Time_dateToEpoch
 Time_epochToDate
 Time_dateDiff
Time_dateToEpoch
Prototipo long Time_dateToEpoch ( TimeStruct * ts);
Devoluciones Número de segundos desde el 1 de enero de 1970
0h00mn00s.
Descripción Esta función devuelve el tiempo UNIX: número de

segundos desde el 1 de enero de 1970, 0h00mn00s.
Parámetros:
 ts: hora y valor de fecha para calcular la hora
de UNIX.
Requiere Nada.
Ejemplo #include "timelib.h"

...
TimeStruct ts1;
larga epoca
...
/ *
* ¿Cuál es la época de la fecha en ts?
* /
epoch = Time_dateToEpoch (& ts1);
Time_epochToDate
Prototipo void Time_epochToDate ( long e, TimeStruct * ts);
Devoluciones Nada.
Descripción Convierte la hora y la hora de UNIX.

Parámetros:
 e: Tiempo UNIX (segundos desde la época
UNIX)
 ts: Estructura de fecha y hora para almacenar
la salida de conversión.
Requiere Nada.

...
TimeStruct ts2;
larga epoca
...
/ *
* ¿Qué fecha es la época 1234567890?
* /
época = 1234567890;
Time_epochToDate (epoch, & ts2);
Time_dateDiff
Prototipo long Time_dateDiff ( TimeStruct * t1, TimeStruct *
t2);
Devoluciones La diferencia de tiempo en segundos como un largo
firmado.
Descripción Esta función compara dos fechas y devuelve la diferencia

de tiempo en segundos como un largo firmado. El resultado
es positivo si t1es anterior t2, el resultado es nulo si t1es
el mismo que t2 y el resultado es negativo si t1es
posterior t2.
Parámetros:
 t1: estructura de fecha y hora (el primer
parámetro de comparación)
 t2: estructura de fecha y hora (el segundo
parámetro de comparación)
Nota: Esta función se implementa como macro en el

archivo de cabecera timelib.h que se puede encontrar en la
carpeta de ejemplo de mikroC PRO for PIC Time Library
Demo.
Requiere Nada.

...
TimeStruct ts1, ts2;
larga diferencia
...
/ *
* ¿Cuántos segundos entre estas dos fechas
contenidas en los buffers ts1 y ts2?
* /
diff = Time_dateDiff (& ts1, & ts2);
Demostración del uso de las rutinas de la biblioteca de tiempo para cálculos de
tiempo en formato de tiempo UNIX.
#include "timelib.h"
TimeStruct ts1, ts2;

larga epoca
larga diferencia
void main () {
ts1.ss = 0;
ts1.mn = 7;
ts1.hh = 17;
ts1.md = 23;
ts1.mo = 5;
ts1.yy = 2006;
/ *
* ¿Cuál es la época de la fecha en ts?
* /
epoch = Time_dateToEpoch (& ts1); // 1148404020
/ *
* ¿Qué fecha es la época 1234567890?
* /
época = 1234567890;
Time_epochToDate (epoch, & ts2); // {0x1E, 0x1F, 0x17, 0x0D, 0x04,
0x02, 0x07D9}
/ *
* ¿Cuántos segundos hay entre estas dos fechas?
* /
diff = Time_dateDiff (& ts1, & ts2); // 86163870
}
Biblioteca de trigonometría
El mikroC PRO for PIC implementa funciones de trigonometría fundamentales. Estas
funciones se implementan como tablas de consulta. Las funciones de trigonometría
se implementan en formato entero para ahorrar memoria.
 sinE3
 cosE3
sinE3
Prototipo int sinE3 ( angle_deg sin signo);
Devoluciones La función devuelve el seno del parámetro de entrada.
Descripción La función calcula el seno multiplicado por 1000 y

redondeado al entero más cercano:
result = round ( sin (angle_deg) * 1000)
Parámetros:
 angle_deg: ángulo de entrada en grados
Nota: rango de valor de retorno:-1000..1000
Requiere Nada.
Ejemplo int res;

...
res = sinE3 (45); // el resultado es 707
cosE3
Prototipo int cosE3 ( angle_deg sin signo);
Devoluciones La función devuelve el coseno del parámetro de entrada.

Descripción La función calcula el coseno multiplicado por 1000 y
redondeado al entero más cercano:
resultado = redondo ( cos (angle_deg) * 1000)
Parámetros:
 angle_deg: ángulo de entrada en grados
Nota: rango Valor de retorno: -1000..1000.
Requiere Nada.
Ejemplo int res;

...
res = cosE3 (196); // el resultado es -961
Gerente de biblioteca
Library Manager permite el manejo sencillo de bibliotecas que se utilizan en un
proyecto. La ventana del Administrador de bibliotecas enumera todas las bibliotecas
(extensión .mcl) que se almacenan instantáneamente en la carpeta Usos del
compilador . La biblioteca deseable se agrega al proyecto seleccionando la casilla de
verificación junto al nombre de la biblioteca.
Para tener acceso a todas las funciones de la biblioteca, simplemente presione el
botón Verificar todas y se seleccionarán todas las bibliotecas. En caso de que
no se necesite ninguna biblioteca en un proyecto, presione el botón Borrar
todo y todas las bibliotecas se borrarán del proyecto.
Solo se enlazarán las bibliotecas seleccionadas.
Icono Descripción
Actualice la biblioteca escaneando los archivos en la carpeta "Usos". Útil

cuando se agregan nuevas bibliotecas copiando los archivos a la
carpeta "Usos".
Reconstruye todas las bibliotecas disponibles. Útil cuando las fuentes de

la biblioteca están disponibles y necesitan actualización.
Incluir todas las bibliotecas disponibles en el proyecto actual.
No se incluirán bibliotecas de la lista en el proyecto actual.
Restaure la biblioteca al estado justo antes de guardar el último

proyecto.
Gestionar bibliotecas utilizando el Administrador de paquetes
El Package Manager es una herramienta que permite a los usuarios instalar
fácilmente sus propias bibliotecas en el mikroIDE. Las bibliotecas se distribuyen en
forma de un paquete, que es un archivo compuesto por uno o más archivos, que
contienen bibliotecas. Para obtener más información sobre Package Manager, visite
nuestro sitio web.
Tras la instalación del paquete, se creará un nuevo nodo con el nombre del paquete
en el Administrador de bibliotecas. Por ejemplo :
Desde el Administrador de bibliotecas, el usuario también puede desinstalar el
paquete deseado haciendo clic con el botón derecho en el nodo apropiado, y en el
menú desplegable, elija Desinstalar paquete:
Temas relacionados: mikroC PRO para bibliotecas PIC , creando una nueva
biblioteca
Creando nueva biblioteca

mikroC PRO for PIC le permite crear sus propias bibliotecas. Para crear una
biblioteca en mikroC PRO para PIC, siga los pasos a continuación:
1. Cree un nuevo archivo de origen, vea Administrar archivos de origen
2. Guarde el archivo en una de las subcarpetas de la carpeta Usos del
compilador:
DriveName:\Program Files\Mikroelektronika\mikroC PRO for
PIC\Uses\P16\
PIC\Uses\P18\
si está creando una biblioteca para la familia de MCU PIC16, el archivo
debe guardarse en la carpeta P16.
Si está creando una biblioteca para la familia de MCU PIC18, el archivo
debe guardarse en la carpeta P18.
Si está creando una biblioteca para las familias PIC16 y PIC18 MCU, el
archivo debe guardarse en ambas carpetas.
3. Escribe un código para tu biblioteca y guárdalo.
4. Agregar __Lib_Examplearchivo en algún proyecto, ver Administrador de
proyectos. Recompila el proyecto.
Si desea utilizar esta biblioteca para todas las MCU, debe ir
a Herramientas ›Opciones› Configuración de salida y marcar
la casilla Crear todos los archivos como biblioteca .
Esto creará bibliotecas en una forma común que funcionará con todas
las MCU. Si esta casilla no está marcada, la biblioteca se construirá para
la MCU seleccionada.
Tenga en cuenta que el compilador informará un error si se utiliza una
biblioteca creada para MCU específica para otra.
5. El archivo compilado __Lib_Example.mcldebe aparecer en la ...\mikroC
PRO for PIC\Uses\carpeta.
6. Abra el archivo de definición de la MCU que desea utilizar. Este archivo
se coloca en la carpeta Defs del compilador:
PIC\Defs\
y se nombra MCU_NAME.mlk, por ejemplo16F887.mlk
7. Agregue el siguiente segmento de código al <LIBRARIES>nodo del
archivo de definición (el archivo de definición está en formato XML):
<LIB>
<ALIAS>Example_Library</ALIAS>
<FILE>__Lib_Example</FILE>
<TYPE>REGULAR</TYPE>
</LIB>
8. Agregue Biblioteca al archivo mlk para cada MCU que desee usar con su
biblioteca.
9. Haga clic en el botón Actualizar en el Administrador de biblioteca
10. Example_Library Debería aparecer en la ventana del administrador de
la biblioteca.
Versiones múltiples de la biblioteca
El alias de biblioteca representa un nombre único que está vinculado al .mclarchivo
de biblioteca correspondiente . Por ejemplo, la biblioteca UART para 16F887 es
diferente de la biblioteca UART para 18F4520 MCU. Por lo tanto, se crearon dos
versiones diferentes de UART Library, vea los mlkarchivos de estas dos MCU. Tenga
en cuenta que estas dos bibliotecas tienen el mismo alias de biblioteca (UART) en
ambos mlkarchivos. Este enfoque le permite tener una representación idéntica de la
biblioteca UART para ambas MCU en el Administrador de bibliotecas .
Temas relacionados: Administrador de biblioteca , Administrador de
proyectos , Administración de archivos de origen
Archivos fuente
Los archivos fuente que contienen código fuente deben tener la extensión .c. La
lista de archivos de origen relevantes para la aplicación se almacena en un archivo
de proyecto con extensión .mcppi, junto con otra información del proyecto. Puede
compilar archivos de origen solo si son parte del proyecto.
Use la directiva del preprocesador #includepara incluir archivos de encabezado con
la extensión .h. No confíe en que el preprocesador incluya archivos de origen que
no sean encabezados; consulte Agregar / Eliminar archivos del
proyecto para obtener más información.
Administrar archivos de origen
Creando nuevo archivo fuente
Para crear un nuevo archivo fuente, haga lo siguiente:
1. Seleccione Archivo ›Nueva unidad en el menú desplegable, o
presione Ctrl + N , o haga clic en el icono Nuevo archivo en la barra

de herramientas Archivo.
2. Se abrirá una nueva pestaña. Este es un nuevo archivo
fuente. Seleccione Archivo ›Guardar en el menú desplegable, o
presione Ctrl + S , o haga clic en el icono Guardar archivo de la barra
de herramientas de archivos y asígnele elnombre que desee.
Si utiliza el Asistente para nuevo proyecto.c , se creará automáticamente un
archivo de origen vacío, que lleva el nombre del proyecto con extensión . El mikroC
PRO for PIC no requiere que tenga un archivo fuente con el mismo nombre que el
proyecto, es solo una cuestión de conveniencia.
Abriendo un archivo existente
1. Seleccione Archivo ›Abrir en el menú desplegable, o
presione Ctrl + O , o haga clic en el icono Abrir archivo en la barra
de herramientas Archivo . En el cuadro de diálogo Abrir, busque la
ubicación del archivo que desea abrir, selecciónelo y haga clic en el
botón Abrir.
2. El archivo seleccionado se muestra en su propia pestaña. Si el archivo
seleccionado ya está abierto, su pestaña Editor actual se activará.
Imprimiendo un archivo abierto
1. Asegúrese de que la ventana que contiene el archivo que desea
imprimir sea la ventana activa.
2. Seleccione Archivo ›Imprimir en el menú desplegable, o
presione Ctrl + P .
3. En la ventana de Vista previa de impresión, configure el diseño deseado
del documento y haga clic en el botón Aceptar. El archivo se imprimirá
en la impresora seleccionada.
Guardando archivo
1. Asegúrese de que la ventana que contiene el archivo que desea guardar
sea la ventana activa.
2. Seleccione Archivo ›Guardar en el menú desplegable, o
presione Ctrl + S , o haga clic en el icono Guardar archivo en la barra
de herramientas de archivos .
Guardando archivo bajo un nombre diferente
1. Asegúrese de que la ventana que contiene el archivo que desea guardar
sea la ventana activa.
2. Seleccione Archivo ›Guardar como en el menú desplegable. Se
mostrará el cuadro de diálogo Nuevo nombre de archivo.
3. En el cuadro de diálogo, vaya a la carpeta donde desea guardar el
archivo.
4. En el campo Nombre de archivo, modifique el nombre del archivo que
desea guardar.
5. Haga clic en el botón Guardar.
Archivo de cierre
1. Asegúrese de que la pestaña que contiene el archivo que desea cerrar
sea la pestaña activa.
2. Seleccione Archivo ›Cerrar en el menú desplegable, o haga clic con
el botón derecho en la pestaña del archivo que desea cerrar y
seleccione Cerrar opción en el menú contextual.
3. Si el archivo se ha modificado desde la última vez que se guardó, se le
solicitará que guarde los cambios.
Rutas de búsqueda
Puede especificar sus propias rutas de búsqueda personalizadas:
seleccione Proyecto ›Editar ruta de búsqueda ... opción en el menú
desplegable:
Las siguientes opciones están disponibles:
Icono Descripción
Añadir ruta de búsqueda.
Eliminar ruta de búsqueda.
Purgar caminos inválidos.
Rutas para archivos fuente ( .c)

Puede especificar una ruta absoluta o relativa al archivo de origen. Si especifica una
ruta relativa, mikroC PRO para PIC buscará el archivo en las siguientes ubicaciones,
en este orden particular:
1. la carpeta del proyecto (carpeta que contiene el archivo del
proyecto .mcppi),
2. sus rutas de búsqueda personalizadas,
3. mikroC PRO for PIC carpeta de instalación> Usescarpeta.
Rutas para archivos de encabezado ( .h)
Los archivos de encabezado se incluyen mediante una directiva de
preprocesador #include. Si coloca una ruta explícita al archivo de encabezado en la
directiva del preprocesador, solo se buscará esa ubicación.
Puede especificar una ruta absoluta o relativa al encabezado. Si especifica una ruta
relativa, mikroC PRO para PIC buscará el archivo en las siguientes ubicaciones, en
este orden particular:
1. la carpeta del proyecto (carpeta que contiene el archivo del
proyecto .h),
2. mikroC PRO for PIC carpeta de instalación> Includecarpeta.
3. sus rutas de búsqueda personalizadas
Temas relacionados: Menú Archivo , Barra de herramientas
Archivo , Gerente de Proyecto, Configuración del proyecto ,
Gerente de proyecto
Project Manager es una función IDE que permite a los usuarios gestionar múltiples
proyectos. Varios proyectos que en conjunto forman un grupo de proyecto pueden
estar abiertos al mismo tiempo. Solo uno de ellos puede estar activo en este
momento.
La configuración del proyecto en modo activo se realiza haciendo doble clic en el
proyecto deseado en el Administrador de proyectos, lo que resultará en el nombre
del proyecto en negrita.
Además, el nombre del proyecto actualmente activo se mostrará en el título de la
ventana del Administrador de programas, junto con la cantidad de proyectos en el
grupo de proyectos.
Las siguientes opciones están disponibles en el Project Manager:

Icono Descripción
Guardar proyecto de grupo.
Grupo de proyecto abierto.
Cierre el proyecto activo.
Cerrar grupo de proyecto.
Añadir proyecto al grupo de proyectos.
Eliminar proyecto del grupo de proyectos.
Añadir archivo al proyecto activo.
Eliminar el archivo seleccionado del proyecto.
Construye el proyecto activo.
Ejecutar el programador Flash de mikroElektronika.

Para obtener detalles sobre cómo agregar y eliminar archivos del proyecto,
vea Agregar / Eliminar archivos del proyecto .
Herramientas
El mikroC PRO para PIC incluye la pestaña Herramientas, que permite el uso de
accesos directos a programas externos, como Calculadora o Bloc de notas.
Puede configurar hasta 10 accesos directos diferentes, editando Tool0 - Tool9.
Ajustes de salida
Al modificar la configuración de salida, el usuario puede configurar el contenido de
los archivos de salida.
Puede habilitar o deshabilitar, por ejemplo, la generación de ASM y el archivo de
lista.
Además, el usuario puede elegir el nivel de optimización y la configuración
específica del compilador, que incluye la sensibilidad a las mayúsculas y
minúsculas, el enlace dinámico para la configuración de literales de cadena
(descrito en mikroC PRO para las especificaciones PIC ).
Crear todos los archivos como biblioteca permite al usuario utilizar la biblioteca
compilada ( *.mcl) en cualquier MCU (cuando esta casilla está marcada), o para
una MCU seleccionada (cuando esta casilla no está marcada).
Para obtener más información sobre la creación de nuevas bibliotecas,
consulte Crear una nueva biblioteca .
Editor de código
El Editor de Código es un editor de texto avanzado diseñado para satisfacer las
necesidades de los profesionales. La edición de código general es lo mismo que
trabajar con cualquier editor de texto estándar, incluidas las acciones familiares de
Copiar, Pegar y Deshacer, comunes en el entorno de Windows.
Las opciones disponibles del Editor de código son: Configuración del editor, Colores
del editor, Corrección automática, Completar automáticamente y Estilo.
Configuraciones del editor
Las características principales de la configuración del editor son:
 Guardar automáticamente
 Resaltador
 Ortografía
 Estilo de comentario
 Código Plegable
 Asistente de código
 Asistente de parámetros
 Marcadores e ir a la línea
Guardar automáticamente
Auto Save es una función que guarda automáticamente un proyecto abierto, lo que
ayuda a reducir el riesgo de pérdida de datos en caso de un bloqueo o
congelación. El guardado automático se realiza en intervalos de tiempo definidos
por el usuario.
Resaltador
Resaltar es una característica conveniente para detectar corchetes que indican el
comienzo o el final de una rutina, al hacerlos visualmente distintos.
Ortografía
El corrector ortográfico subraya los objetos desconocidos en el código, para que se
puedan notar y corregir fácilmente antes de compilar su proyecto.
Seleccione Herramientas ›Opciones en el menú desplegable, o haga clic en el
icono Mostrar opciones y luego seleccione la pestaña Corrector ortográfico.

Estilo de comentario
El Editor de código tiene una función para cambiar el estilo de comentario a una
sola línea o multilínea. Comentar o no comentar el código seleccionado se realiza
con un simple clic del mouse, utilizando el icono de comentario y el icono de
comentario de la barra de herramientas de edición avanzada.
Código Plegable
El plegado de código es una función IDE que permite a los usuarios ocultar y
mostrar de manera selectiva las secciones de un archivo fuente. De esta manera,
es más fácil administrar grandes regiones de código dentro de una ventana,
mientras se siguen viendo solo aquellas subsecciones del código que son relevantes
durante una sesión de edición en particular.
Mientras se escribe, los símbolos de código plegado ( y ) aparecen
automáticamente. Utilice los símbolos de plegado para ocultar / mostrar las
subsecciones de código.
Otra forma de plegar / desplegar subsecciones de código es

usando Alt + ← y Alt + → .
Si coloca el cursor del mouse sobre el cuadro de información sobre herramientas, el
texto contraído se mostrará en un cuadro de estilo de información sobre
herramientas.
Asistente de código
Si escribe las primeras letras de una palabra y luego presiona Ctrl + Space , todos los
identificadores válidos que coincidan con las letras que ha escrito se mostrarán en
un panel flotante (vea la imagen a continuación). Ahora puede seguir escribiendo
para limitar la elección, o puede seleccionar una de la lista con las flechas del
teclado y Enter .
Asistente de parámetros
El Asistente de parámetros se invocará automáticamente cuando abra el paréntesis
“(” o presione Shift + Ctrl + Space . Si el nombre de una función válida precede al
paréntesis, los parámetros esperados se mostrarán en un panel flotante. A medida
que escribe el parámetro real, El siguiente parámetro esperado se pondrá en
negrita.
Marcadores
Los marcadores hacen que la navegación a través de un código grande sea más
fácil. Para establecer un marcador, use Ctrl + Shift + number . El mismo principio se
aplica a la eliminación de los marcadores. Para saltar a un marcador,
usa Ctrl + number .
Ir a la linea
La opción Ir a la línea facilita la navegación a través de un código grande. Usa el
atajo Ctrl + G para activar esta opción.
Modo de selección de columna
Este modo cambia la operación del editor para seleccionar texto. Cuando se utiliza
el modo de selección de columna, el texto resaltado se basa en la posición de la
columna de caracteres del primer carácter seleccionado en la columna del último
carácter del texto seleccionado.
El texto seleccionado en este modo no incluye automáticamente todo el texto entre
la posición inicial y final, pero incluye todo el texto en las columnas entre el primer
y el último carácter seleccionado.
La edición del modo de columna a veces se denomina edición del modo de
bloque, ya que el hecho de seleccionar texto forma un rectángulo.
Para ingresar a este modo, presione Alt + botón izquierdo del ratón, arrastre el
mouse hacia la dirección deseada y seleccione el texto.
Colores del editor
La opción de colores del editor permite al usuario configurar, cambiar y guardar las
configuraciones de texto y color organizadas en esquemas. Los esquemas
representan una apariencia gráfica personalizada que se puede aplicar a la GUI
(Interfaz Gráfica de Usuario) para los gustos satifsy de diferentes usuarios.
Auto corregir
La opción Corrección automática facilita al usuario de tal manera que corrige
automáticamente los errores comunes de escritura o ortografía a medida que se
escribe.
Esta opción ya está configurada para corregir automáticamente algunas

palabras. Por ejemplo, si escribe whiel, se corregirá whilecuando presione la barra
espaciadora:
El usuario puede agregar fácilmente sus errores tipográficos comunes ingresando
un error tipográfico original, por ejemplo btye, en el cuadro Original y el
reemplazo byte, en el cuadro Reemplazo, y simplemente haga clic en el botón
"Agregar".
La próxima vez que ocurra el error tipográfico, se corregirá automáticamente.
Auto Completo (Plantillas de Código)

La opción Autocompletar guarda muchas pulsaciones de teclado para frases de uso
común al completar automáticamente la escritura del usuario.
El usuario puede insertar la plantilla de código escribiendo el nombre de la plantilla
(por ejemplo, dow), luego presionar Ctrl + J y el editor de código generará
automáticamente un código:
Puede agregar sus propias plantillas a la lista ingresando la palabra clave deseada,
la descripción y el código de su plantilla en los cuadros correspondientes.
Las macros autocompletadas pueden recuperar información del sistema y del
proyecto:
 %DATE% - fecha actual del sistema

 %TIME% - hora actual del sistema
 %DEVICE% - nombre del dispositivo (MCU) como se especifica en la
configuración del proyecto
 %DEVICE_CLOCK% - reloj como se especifica en la configuración del
proyecto
 %COMPILER% - versión actual del compilador
Estas macros se pueden utilizar en el código de la plantilla, consulte la
plantilla ptemplateprovista con mikroC PRO para la instalación de PIC.

MikroC PRO para Bibliotecas PIC

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

MikroC PRO para Bibliotecas PIC

Cargado por

Copyright:

Formatos disponibles

mikroC PRO para bibliotecas PIC

mikroC PRO para PIC proporciona un conjunto de bibliotecas que simplifican la

Devoluciones Los 8 bits más bajos (byte) de param, bits 7..0.

Descripción La función devuelve el byte más bajo de param. La función

Lo (d) = 0xAA; // d es igual a 0x123456AA

Devoluciones Devuelve junto al byte más bajo de param, bits 8..15.

Descripción La función regresa al lado del byte más bajo de param. La

Hola (d) = 0xAA; // d es igual a 0x1234AA78

Superior (d) = 0xAA; // d es igual a 0x12AA5678

Devoluciones Devuelve el byte más alto de param, bits 24..31.

Descripción La función devuelve el byte más alto de param. La función

Más alto (d) = 0xAA; // d es igual a 0xAA345678

Descripción La función devuelve baja palabra de number. La función no

Parámetros  number: número de entrada

Devoluciones Baja palabra de number, bits 15..0.

LoWord (d) = 0xAAAA; // d es igual a 0x1234AAAA

Descripción La función devuelve alta palabra de number. La función no

Parámetros  number: número de entrada

Devoluciones Palabra alta de number, bits 31..16.

HiWord (d) = 0xAAAA; // d es igual a 0xAAAA5678

Descripción Crea un retraso de software en la duración

Ejemplo Delay_us (1000); / * Una pausa de milisegundos * /

Descripción Crea un retraso de software en la duración

Ejemplo Delay_ms (1000); / * Una pausa de un segundo * /

Descripción Crea un retraso de software en la duración

Ejemplo pausa = 1000;

Descripción Crea un retraso de software en la duración

Ejemplo pausa = 1000;

VDelay_Advanced_ms (pausa, fosc); // Genera

Descripción Crea un retraso basado en el reloj MCU. La demora dura 10

Ejemplo Delay_Cyc (10); / * Cien ciclos de MCU en pausa * /

Devoluciones Reloj del dispositivo en kHz, redondeado al entero más

Descripción La función devuelve el reloj del dispositivo en kHz,

Ejemplo clk = Clock_kHz ();

Devoluciones Reloj del dispositivo en MHz, redondeado al entero más

Descripción La función devuelve el reloj del dispositivo en MHz,

Ejemplo clk = Clock_MHz ();

Devoluciones Reloj del dispositivo en kHz, redondeado al entero más

Descripción La función devuelve el reloj del dispositivo en kHz,

Ejemplo clk = Get_Fosc_kHz ();

Devoluciones Intercambiar nibbles del byte de entrada.

Descripción Función swaps nibbles del inputparámetro.

Ejemplo Char de entrada, swapped_input;

Descripción Esta rutina inicializa el módulo ADC interno de PIC para

Requiere  MCU con módulo ADC incorporado .

Ejemplo ADC_Init (); // Inicializar el módulo ADC con la

Devoluciones Se leyó un valor sin signo de 10 o 12 bits del canal

Descripción La función adquiere valor analógico del canal especificado.

Nota: esta función no funciona con la fuente de

Requiere  La MCU con módulo ADC incorporado .

Ejemplo sin signo adc_value;

Devoluciones Se leyó un valor sin signo de 10 o 12 bits del canal

Descripción Inicializa el módulo ADC interno de PIC para que funcione

Nota: esta función no funciona con la fuente de

Requiere  La MCU con módulo ADC incorporado .

Ejemplo sin firma tmp;

unsigned int temp_res;

TRISA = 0xFF; // PORTA es la entrada

 Consulte la norma CAN sobre la resistencia de terminación del

Descripción Establece CAN en el modo solicitado, es decir,

Requiere El microcontrolador debe estar conectado

Ejemplo CANSetOperationMode (_CAN_MODE_CONFIG, 0xFF);

Devoluciones Opmode actual.