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 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 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 táctil Touch TFT Library Biblioteca UART Biblioteca extraíble UART Biblioteca USB
Bibliotecas ANSI C estándar
Biblioteca Biblioteca Biblioteca Biblioteca
ANSI C Ctype de matemáticas ANSI C ANSI C Stdlib de cadenas ANSI C
Bibliotecas misceláneas
Biblioteca de botones Biblioteca de conversiones Biblioteca de PrintOut
Biblioteca Biblioteca Biblioteca Biblioteca
de Setjmp Sprint de tiempo 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. 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 = 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. 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 = 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 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 = 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 devuelve 16 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 .
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 devuelve 16 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 .
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. 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 . 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);
Delay_ms
/ * Una pausa de milisegundos * /
Prototipo
void Delay_ms ( const unsigned long time_in_ms);
Devoluciones
Nada.
Descripción
Crea un retraso de software en la duración de time_in_msmilisegundos (una constante). El rango de constantes aplicables depende de la frecuencia del oscilador. 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 . 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.
Descripción
Crea un retraso de software en la duración 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.
Descripción
Crea un retraso de software en la duración 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 en lugar de una rutina incorporada; Se presenta en este 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 en lugar de una rutina incorporada; Se presenta en este 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. 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
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, redondeado al entero más cercano.
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
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, redondeado al entero más cercano. 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. 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
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 Ejemplo
MCU con módulo ADC incorporado .
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
Ejemplo
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.
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
Ejemplo
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.
sin firma tmp; ... tmp = ADC_Read (2); canal 2
// Leer valor analógico del
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; ANSELH = 0; digital C1ON_bit = 0; C2ON_bit = 0; TRISA = 0xFF; TRISC = 0; TRISB = 0; hacer { temp_res = ADC_Read (2); conversión AD AD PORTB = temp_res; PORTC = temp_res >> 8; RC0 } while (1); }
Conexión HW
// Configurar el pin AN2 como analógico // Configurar otros pines AN como E / S // Desactivar comparadores // PORTA es la entrada // PORTC es salida // PORTB es la salida // Obtener resultados de 10 bits de la // Enviar 8 bits más bajos a PORTB // Enviar 2 bits más significativos a RC1,
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 .
Rutinas de la biblioteca
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 (M2551 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 .
Requiere
El microcontrolador debe estar conectado al transceptor CAN (M2551 o similar) que está conectado al bus CAN .
Ejemplo
if (CANGetOperationMode () == _CAN_MODE_NORMAL) {...};
CANInicializar Prototip o
anular CANInitialize ( Char SJW, Char BRP, Char PHSEG1, CharPHSEG2, Char PR OPSEG, Char CAN_CONFIG_FLAGS);
Devoluci ones
Nada.
Descripc ión
Inicializa CAN . Todas las transmisiones pendientes son 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) PHSEG2 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 e
CAN debe estar en modo Config; De lo contrario, la función será ignorada. El microcontrolador debe estar conectado al transceptor CAN (M2551 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 o
void CANSetBaudRate ( char SJW, char BRP, char PHSEG1, char PHSEG2, char P ROPSEG, char CAN_CONFIG_FLAGS);
Devoluc iones
Nada.
Descripc ión
Ajusta la velocidad de transmisión de CAN . Debido a la 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) PHSEG1 como se define en la hoja de datos (1–8) PHSEG2 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 e
CAN debe estar en modo Config; De lo contrario, la función será ignorada. El microcontrolador debe estar conectado al transceptor CAN (M2551 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; ... CANSetBaudRate (1, 1, 3, 3, 1, init);
CANSetMask Prototipo
void CANSetMask ( char CAN_MASK, valor largo , char CAN_CONFIG_FLA GS);
Devolucione s
Nada.
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. El microcontrolador debe estar conectado al transceptor CAN (M2551 o similar) que está conectado 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 s
Nada.
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. El microcontrolador debe estar conectado al transceptor CAN (M2551 o similar) que está conectado 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. El microcontrolador debe estar conectado al transceptor CAN (M2551 o similar) que está conectado al bus CAN .
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. El microcontrolador debe estar conectado al transceptor CAN (M2551 o similar) que está conectado al bus CAN .
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 para evitar la interferencia de señal en CANTX de otros pines cercanos.
_CAN_DRIVE_HIGH_STATE_ENABLE
El pin CANTX será de tres estados cuando sea recesivo.
_CAN_DRIVE_HIGH_STATE_DISABLE
Requiere
El microcontrolador debe estar conectado al transceptor CAN (M2551 o similar) que está conectado al bus CAN .
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, _CAN_CONFIG_PHSEG2_PRG_OFF = 0xFE, _CAN_CONFIG_LINE_FILTER_BIT = 0x02, _CAN_CONFIG_LINE_FILTER_ON = 0xFF, _CAN_CONFIG_LINE_FILTER_OFF = 0xFD, _CAN_CONFIG_SAMPLE_BIT = 0x04, _CAN_CONFIG_SAMPLE_ONCE = 0xFF, _CAN_CONFIG_SAMPLE_THRICE = 0xFB,
// XXXXXXX1 // XXXXXXX0 // XXXXXX1X // XXXXXX0X // XXXXX1XX // 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, _CAN_CONFIG_DBL_BUFFER_OFF = 0xEF,
// XXX1XXXX // 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: Copiar código al portapapeles
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
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, _CAN_TX_PRIORITY_1 = 0xFD, _CAN_TX_PRIORITY_2 = 0xFE, _CAN_TX_PRIORITY_3 = 0xFF, _CAN_TX_FRAME_BIT = 0x08, _CAN_TX_STD_FRAME = 0xFF, _CAN_TX_XTD_FRAME = 0xF7,
// // // //
XXXXXX00 XXXXXX01 XXXXXX10 XXXXXX11
// XXXXX1XX // 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: Copiar código al portapapeles
// 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_FILTER_2 = 0x01, _CAN_RX_FILTER_3 = 0x02, _CAN_RX_FILTER_4 = 0x03, _CAN_RX_FILTER_5 = 0x04, _CAN_RX_FILTER_6 = 0x05, _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 Puede usar AND ( &) a nivel de bits para ajustar los indicadores apropiados. Por ejemplo: Copiar código al portapapeles
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_B1_F2 = 1, _CAN_FILTER_B2_F1 = 2, _CAN_FILTER_B2_F2 = 3, _CAN_FILTER_B2_F3 = 4, _CAN_FILTER_B2_F4 = 5;
Ejemplo de biblioteca 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:
Copiar código al portapapeles
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; PORTC TRISC = 0; PORTC como salida
// borrar
Can_Init_Flags = 0; Can_Send_Flags = 0; banderas Can_Rcv_Flags = 0;
// // borrar las
// establece
//
Can_Send_Flags = _CAN_TX_PRIORITY_0 & formulario que se utilizará _CAN_TX_XTD_FRAME & CANWrite _CAN_TX_NO_RTR_FRAME;
// valor de
Can_Init_Flags = _CAN_CONFIG_SAMPLE_THRICE & formulario que se utilizará _CAN_CONFIG_PHSEG2_PRG_ON & CANInit _CAN_CONFIG_XTD_MSG & _CAN_CONFIG_DBL_BUFFER_ON & _CAN_CONFIG_VALID_XTD_MSG;
// valor de
// con
// con
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 CANSetMask (_CAN_MASK_B2, -1, _CAN_CONFIG_XTD_MSG); // 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); el modo NORMAL
// establece
RxTx_Data [0] = 9; los datos iniciales para ser enviados
// configurar
CANWrite (ID_1st, RxTx_Data, 1, Can_Send_Flags); mensaje inicial
// enviar
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: Copiar código al portapapeles
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; PORTC TRISC = 0; PORTC como salida
// borrar
Can_Init_Flags = 0; Can_Send_Flags = 0; banderas Can_Rcv_Flags = 0;
// // borrar las
// establece
//
Can_Send_Flags = _CAN_TX_PRIORITY_0 & formulario que se utilizará _CAN_TX_XTD_FRAME & CANWrite _CAN_TX_NO_RTR_FRAME;
// valor de
Can_Init_Flags = _CAN_CONFIG_SAMPLE_THRICE & formulario que se utilizará _CAN_CONFIG_PHSEG2_PRG_ON & CANInit _CAN_CONFIG_XTD_MSG & _CAN_CONFIG_DBL_BUFFER_ON & _CAN_CONFIG_VALID_XTD_MSG & _CAN_CONFIG_LINE_FILTER_OFF;
// valor de
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 CANSetMask (_CAN_MASK_B1, -1, _CAN_CONFIG_XTD_MSG); establece todos los bits de mask1 a unos CANSetMask (_CAN_MASK_B2, -1, _CAN_CONFIG_XTD_MSG); establece todos los bits de mask2 a los
// con
// con
// // // //
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); el modo NORMAL
// establece
while (1) { // interminable bucle Msg_Rcvd = CANRead (& Rx_ID, RxTx_Data, & Rx_Data_Len, & Can_Rcv_Flags); // recibir mensaje si ((Rx_ID == ID_1st) && 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 los datos recibidos CANWrite (ID_2nd, RxTx_Data, 1, Can_Send_Flags); // devolver datos incrementados } } }
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 M2515 o M2510) 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 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 definirse en todos los proyectos usando labiblioteca CANSPI :
Descripció n:
Ejemplo:
extern sfr sbitCanSpi_CS;
Chip de selección de línea.
sbit CanSpi_CS atRC0_bit;
extern sfr sbitCanSpi_Rst;
Restablecer línea.
sbit CanSpi_Rst atRC2_bit;
extern sfr sbitCanSpi_CS_Directio n;
Dirección del pin Chip Select.
sbitCanSpi_CS_Direction at TRISC0_ bit;
extern sfr sbitCanSpi_Rst_Directi on;
Dirección del pin de reinicio.
sbitCanSpi_Rst_Direction at TRISC2 _bit;
Rutinas de la biblioteca
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 .
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
// comprueba si el módulo CANSPI está en modo Normal y si está haciendo algo. if (CANSPIGetOperationMode () == _CANSPI_MODE_NORMAL) { ... }
CANSPIInicializar Prototip o
void CANSPIInitialize ( char SJW, char BRP, char PHSEG1, char PHSEG2, char P ROPSEG, char CANSPI_CONFIG_FLAGS);
Devoluc iones
Nada.
Descrip ción
Inicializa el módulo CANSPI . 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 PHSEG2como se define en la hoja de datos del 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 e
Variables globales : 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 . 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
// 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 o
void CANSPISetBaudRate ( char SJW, char BRP, char PHSEG1, char PHSEG2, char P ROPSEG, char CANSPI_CONFIG_FLAGS);
Devoluc iones
Nada.
Descrip ción
Establece la velocidad en baudios del módulo CANSPI . Debido a 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
PHSEG1como se define en la hoja de datos del
controlador CAN PHSEG2como se define en la hoja de datos del 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 e
El módulo CANSPI debe estar en modo Config. De lo contrario, la función se ignorará. Ver CANSPISetOperationMode . 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
// 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_DBL_BUFFER_ON & _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 es
Nada.
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_MATCH_MSG_TYPE & _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 . 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
// establece la máscara de filtro y el valor de tipo de mensaje apropiados CANSPISetOperationMode (_CANSPI_MODE_CONFIG, 0xFF); // establecer el modo CONFIGURACIÓN (el módulo CANSPI 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 es
Nada.
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 (ver constantes CANSPI ) 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_MATCH_MSG_TYPE & _CANSPI_CONFIG_STD_MSG, _CANSPI_CONFIG_MATCH_MSG_TYPE & _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 . 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
// establece el valor de filtro apropiado y el tipo de mensaje 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 del filtro) / * Establecer id del filtro B1_F1 a 3: * / CANSPISetFilter (_CANSPI_FILTER_B1_F1, 3, _CANSPI_CONFIG_XTD_MSG);
CANSPIRead Prototipo
Devoluciones
char CANSPIRead ( long * id, char * rd_data, char * data_len, char * CANSPI_RX_MSG_FLAGS);
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 .
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
// 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
Devoluciones
char CANSPIWrite ( id largo , char * wr_data, char data_len, char CANSPI_TX_MSG_FLAGS);
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 . 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
// enviar mensaje extendida mensaje CAN con el ID y datos apropiados de char tx_flags; datos de carácter [8];
long msg_id; ... CANSPISetOperationMode (_CANSPI_MODE_NORMAL, 0xFF); // 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, _CANSPI_CONFIG_PHSEG2_PRG_OFF = 0xFE, _CANSPI_CONFIG_LINE_FILTER_BIT = 0x02, _CANSPI_CONFIG_LINE_FILTER_ON = 0xFF, _CANSPI_CONFIG_LINE_FILTER_OFF = 0xFD, _CANSPI_CONFIG_SAMPLE_BIT = 0x04, _CANSPI_CONFIG_SAMPLE_ONCE = 0xFF, _CANSPI_CONFIG_SAMPLE_THRICE = 0xFB,
// XXXXXXX1 // XXXXXXX0 // XXXXXX1X // XXXXXX0X // XXXXX1XX // 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, _CANSPI_CONFIG_DBL_BUFFER_OFF = 0xEF,
// XXX1XXXX // 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: Copiar código al portapapeles
init = _CANSPI_CONFIG_SAMPLE_THRICE & _CANSPI_CONFIG_PHSEG2_PRG_ON & _CANSPI_CONFIG_STD_MSG & _CANSPI_CONFIG_DBL_BUFFER_ON & _CANSPI_CONFIG_VALID_XTD_MSG & _CANSPI_CONFIG_LINE_FILTER_OFF; ... 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, _CANSPI_TX_PRIORITY_1 = 0xFD, _CANSPI_TX_PRIORITY_2 = 0xFE, _CANSPI_TX_PRIORITY_3 = 0xFF, _CANSPI_TX_FRAME_BIT = 0x08, _CANSPI_TX_STD_FRAME = 0xFF, _CANSPI_TX_XTD_FRAME = 0xF7,
// // // //
XXXXXX00 XXXXXX01 XXXX10 XXXXXX
// XXXXX1XX // XXXXX0XX
_CANSPI_TX_RTR_BIT = 0x40, _CANSPI_TX_NO_RTR_FRAME = 0xFF, // X1XXXXXX _CANSPI_TX_RTR_FRAME = 0xBF; // X0XXXXXX Puede usar AND ( &) a nivel de bits para ajustar los indicadores apropiados. Por
ejemplo: Copiar código al portapapeles
/ * 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_FILTER_2 = 0x01, _CANSPI_RX_FILTER_3 = 0x02, _CANSPI_RX_FILTER_4 = 0x03, _CANSPI_RX_FILTER_5 = 0x04, _CANSPI_RX_FILTER_6 = 0x05, _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
Puede usar AND ( &) a nivel de bits para ajustar los indicadores apropiados. Por ejemplo: Copiar código al portapapeles
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_B1_F2 = 1, _CANSPI_FILTER_B2_F1 = 2, _CANSPI_FILTER_B2_F2 = 3, _CANSPI_FILTER_B2_F3 = 4, _CANSPI_FILTER_B2_F4 = 5;
Ejemplo de biblioteca 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: Copiar código al portapapeles
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; // 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 void main () {
ANSEL = 0; pines AN como E / S digital ANSELH = 0;
// Configurar
PORTB = 0; PORTB TRISB = 0; PORTB como salida
// borrar
Can_Init_Flags = 0; Can_Send_Flags = 0; las banderas Can_Rcv_Flags = 0;
// // borrar
// establece
//
Can_Send_Flags = _CANSPI_TX_PRIORITY_0 & formulario que se utilizará _CANSPI_TX_XTD_FRAME & CANSPIWrite _CANSPI_TX_NO_RTR_FRAME;
// valor de
Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE & formulario que se utilizará _CANSPI_CONFIG_PHSEG2_PRG_ON & CANSPIInit _CANSPI_CONFIG_XTD_MSG & _CANSPI_CONFIG_DBL_BUFFER_ON & _CANSPI_CONFIG_VALID_XTD_MSG;
// Valor de
SPI1_Init (); inicializar el módulo SPI1
// con
// con
//
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_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) { // interminable bucle Msg_Rcvd = CANSPIRead (& 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 PORTB = RxTx_Data [0]; // identificación correcta, datos de salida en PORTC RxTx_Data [0] ++; // incrementar datos recibidos Delay_ms (10);
CANSPIWrite (ID_1st, RxTx_Data, 1, Can_Send_Flags); // devolver datos incrementados } } }
Código para el segundo nodo CANSPI: Copiar código al portapapeles
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; // 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 void main () { ANSEL = 0; pines AN como E / S digital ANSELH = 0; C1ON_bit = 0; Desactivar comparadores C2ON_bit = 0;
// Configurar //
PORTB = 0; PORTB TRISB = 0; PORTB como salida
// borrar
Can_Init_Flags = 0; Can_Send_Flags = 0; las banderas Can_Rcv_Flags = 0;
// // borrar
// establece
//
Can_Send_Flags = _CANSPI_TX_PRIORITY_0 & formulario que se utilizará _CANSPI_TX_XTD_FRAME & CANSPIWrite _CANSPI_TX_NO_RTR_FRAME;
// valor de
Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE & formulario que se utilizará _CANSPI_CONFIG_PHSEG2_PRG_ON & CANSPIInit _CANSPI_CONFIG_XTD_MSG & _CANSPI_CONFIG_DBL_BUFFER_ON & _CANSPI_CONFIG_VALID_XTD_MSG & _CANSPI_CONFIG_LINE_FILTER_OFF;
// Valor de
SPI1_Init (); // inicializar el módulo SPI1
// con
// con
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 CANSPISetOperationMode (_CANSPI_MODE_NORMAL, 0xFF); // establece el modo NORMAL while (1) { // interminable bucle Msg_Rcvd = CANSPIRead (& Rx_ID, RxTx_Data, & Rx_Data_Len, & Can_Rcv_Flags); // recibir mensaje si ((Rx_ID == ID_1st) && Msg_Rcvd) { // si el mensaje recibió la identificación de cheque PORTB = RxTx_Data [0]; // identificación correcta, datos de salida en PORTC RxTx_Data [0] ++; // incrementar los datos recibidos CANSPIWrite (ID_2nd, RxTx_Data, 1, Can_Send_Flags); // devolver datos incrementados } } }
Conexión HW
Ejemplo de interfaz del transceptor CAN M2510 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 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.
Árbol de la dependencia de la biblioteca
Dependencias externas de Compact Flash Library Las siguientes variables deben definirse en todos los proyectos utilizando la biblioteca Compact Flash:
Descripción :
Ejemplo:
extern sfr charCF_Data_Port;
Puerto de datos Compact Flash.
char CF_Data_Port at PORTD;
extern sfr sbit CF_RDY;
Línea de señal lista.
sbit CF_RDY atRB7_bit;
extern sfr sbit CF_WE;
Escribir habilitar línea de señal.
sbit CF_WE atLATB6_bit;
extern sfr sbit CF_OE;
Salida habilitar línea de señal.
sbit CF_OE atLATB5_bit;
extern sfr sbit CF_CD1;
Chip de detección de línea de señal.
sbit CF_CD1 atRB4_bit;
extern sfr sbit CF_CE1;
Chip habilita la línea de señal.
sbit CF_CE1 atLATB3_bit;
extern sfr sbit CF_A2;
Dirección pin 2.
sbit CF_A2 atLATB2_bit;
extern sfr sbit CF_A1;
Dirección pin 1.
sbit CF_A1 atLATB1_bit;
extern sfr sbit CF_A0;
Dirección pin 0.
sbit CF_A0 atLATB0_bit;
extern sfr sbitCF_RDY_direction ;
Dirección del pin Listo.
sbitCF_RDY_direction at TRISB7_bit ;
extern sfr sbitCF_WE_direction;
Dirección del pin Habilitar escritura.
sbitCF_WE_direction at TRISB6_bit;
extern sfr sbitCF_OE_direction;
Dirección del pin de habilitación de salida.
sbitCF_OE_direction at TRISB5_bit;
extern sfr sbitCF_CD1_direction ;
Dirección del pin Chip Detect.
sbitCF_CD1_direction at TRISB4_bit ;
extern sfr sbitCF_CE1_direction ;
Dirección del pin chip habilitado.
sbitCF_CE1_direction at TRISB3_bit ;
extern sfr sbitCF_A2_direction;
Dirección del pin Dirección 2.
sbitCF_A2_direction at TRISB2_bit;
extern sfr sbitCF_A1_direction;
Dirección del pin Dirección 1.
sbitCF_A1_direction at TRISB1_bit;
extern sfr sbitCF_A0_direction;
Dirección de la dirección 0 pin.
sbitCF_A0_direction at TRISB0_bit;
Rutinas de la biblioteca 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_A1 : Dirección pin 1 CF_A0 : Dirección pin 0
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 CF_A1_direction : Dirección del pin Dirección 1 CF_A0_direction : Dirección del pin Dirección 0 Debe ser definido antes de usar esta función.
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 en el pin de salida siempre use latch (familia PIC18 ) sbit CF_A1 at LATB1_bit; // para escribir en el pin de salida siempre use latch (familia PIC18 ) sbit CF_A0 en LATB0_bit; // para escribir en el pin de salida siempre use latch (familia PIC18) sbit sbit sbit sbit sbit sbit sbit
CF_RDY_direction en TRISB7_bit; CF_WE_direction en TRISB6_bit; CF_OE_direction en TRISB5_bit; CF_CD1_direction en TRISB4_bit; CF_CE1_direction en TRISB3_bit; CF_A2_direction en TRISB2_bit; CF_A1_direction en TRISB1_bit;
sbit CF_A0_direction en TRISB0_bit; // fin de cf pinout ... Cf_Init (); // inicializar CF
Cf_Detect Prototipo Devoluciones
corto sin firma Cf_Detect ( void );
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.
Requiere
Los puertos MCU correspondientes deben inicializarse adecuadamente para la tarjeta CF. Ver Cf_Init .
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.
Requiere
Los puertos MCU correspondientes deben inicializarse adecuadamente para la tarjeta CF. Ver Cf_Init .
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.
Requiere
Los puertos MCU correspondientes deben inicializarse adecuadamente para la tarjeta CF. Ver Cf_Init .
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.
Requiere
Los puertos MCU correspondientes deben inicializarse adecuadamente para la tarjeta CF. Ver Cf_Init . 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.
Requiere
Los puertos MCU correspondientes deben inicializarse adecuadamente para la tarjeta CF. Ver Cf_Init .
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.
Requiere
Los puertos MCU correspondientes deben inicializarse adecuadamente para la tarjeta CF. Ver Cf_Init . 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.
Requiere
Los puertos MCU correspondientes deben inicializarse adecuadamente para la tarjeta CF. Ver Cf_Init .
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.
Requiere
Los puertos MCU correspondientes deben inicializarse adecuadamente para la tarjeta CF. Ver Cf_Init .
Ejemplo
// escribir al sector 22 datos cortos sin firmar [512]; ... Cf_Write_Sector (22, datos);
Cf_Fat_Init Prototipo Devoluciones
corto sin firma Cf_Fat_Init ();
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
Descripción
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
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
Devoluciones
Descripción
corto sin signo Cf_Fat_Assign ( char * filename, charfile_cre_attr);
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.
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 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 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
6
0x40
Dispositivo (solo uso interno, nunca encontrado en el disco)
0x80
Bandera de creación de archivo. Si el archivo no existe y se establece este indicador, se creará un nuevo archivo con el nombre especificado.
7
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.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . 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.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . El archivo debe ser asignado previamente. Ver Cf_Fat_Assign . 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.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init .
El archivo debe ser asignado previamente. Ver Cf_Fat_Assign . 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í.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . El archivo debe ser asignado previamente. Ver Cf_Fat_Assign .
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.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . El archivo debe ser asignado previamente. Ver Cf_Fat_Assign .
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.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . El archivo debe ser asignado previamente. Ver Cf_Fat_Assign . 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: 059. seconds:atributo de segundos Valores válidos: 0-59.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . El archivo debe ser asignado previamente. Ver Cf_Fat_Assign . El archivo debe estar abierto para 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. Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . El archivo debe ser asignado previamente. Ver Cf_Fat_Assign .
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 devuelve a través de este parámetro. 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 se devuelve a través de este parámetro. 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
modificación del atributo a. Tras la ejecución de la función, se devuelve el atributo de modificación a través de este parámetro. mins:buffer para almacenar minutos de modificación del atributo a. Tras la ejecución de la función, el atributo de modificación de minutos se devuelve a través de este parámetro.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . El archivo debe ser asignado previamente. Ver Cf_Fat_Assign .
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.
Requiere
La tarjeta CF y la biblioteca CF deben inicializarse para las operaciones de archivo. Ver Cf_Fat_Init . El archivo debe ser asignado previamente. Ver Cf_Fat_Assign .
Ejemplo
unsigned long my_file_size; ... my_file_size = Cf_Fat_Get_File_Size ();
Cf_Fat_Get_Swap_File Prototipo
Devoluciones
unsigned long Cf_Fat_Get_Swap_File ( unsigned long sectores_cnt, char * filename, char file_attr);
Descripción
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. 0 de lo contrario
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 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 desea que tenga el archivo de intercambio. 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 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 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_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
6
0x40
Dispositivo (solo uso interno, nunca encontrado en el disco)
7
0x80
No utilizado
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
// -------------- 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); }
Ejemplo de biblioteca 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); Copiar código al portapapeles
// 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 siempre use latch (familia PIC18 ) sbit CF_A1 at LATB1_bit; // para escribir en el pin de salida siempre use latch (familia 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; sbit CF_A2_direction en TRISB2_bit; sbit CF_A1_direction en TRISB1_bit; sbit CF_A0_direction en TRISB0_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 comenzar con nuevos datos para (loop = 1; loop <= 44; loop ++) { 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 } } } // 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 (); para (loop = 1; loop <= 55; loop ++) { 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 } } // 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_Assign (& filename, 0); Cf_Fat_Set_File_Date (2009, 1, 23, 17, 22, 0); Cf_Fat_Append (); archivo para agregar Cf_Fat_Write (" para mikroElektronika 2010n", 27); en el archivo asignado }
// Preparar // Escribir datos
// Abre un archivo existente, lee los datos y lo coloca en UART void M_Open_File_Read () { char character; nombre de archivo [7] = 'B'; Cf_Fat_Assign (& filename, 0); 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); UART1_Write_Text (outstr); WordToStr (día, outstr); UART1_Write_Text (outstr); WordToStr (hora, outstr); UART1_Write_Text (outstr); WordToStr (minuto, outstr); UART1_Write_Text (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:"); WordToStr (año, outstr); UART1_Write_Text (outstr); ByteToStr (month, outstr); UART1_Write_Text (outstr); WordToStr (día, outstr); UART1_Write_Text (outstr); WordToStr (hora, outstr); UART1_Write_Text (outstr); WordToStr (minuto, outstr); UART1_Write_Text (outstr); // --- 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); ayuda en esta función para más detalles
// vea la
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 .
Rutinas de la biblioteca
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 sin firmar , datos cortos sin // para PIC18 void EEPROM_Write ( dirección sin firmar , datos cortos sin
corta firmar ); int 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);
Ejemplo de biblioteca El ejemplo demuestra el uso de la biblioteca EEPROM . Copiar código al portapapeles
char ii; void main () {
// variable de bucle
ANSEL = 0; digital ANSELH = 0; C1ON_bit = 0; C2ON_bit = 0;
// Configurar pines AN como E / S // Desactivar comparadores
PORTB = 0; PORTC = 0; PORTD = 0; TRISB = 0; TRISC = 0; TRISD = 0; para (ii = 0; ii <32; ii ++) EEPROM_Write (0x80 + ii, ii); dirección 0x80 + ii
// Rellenar el búfer de datos // Escribe los datos en la
EEPROM_Write (0x02,0xAA); dirección 2 EEPROM_Write (0x50,0x55); dirección 0150
// Escriba algunos datos en la
Delay_ms (1000); PORTB y PORTC PORTB = 0xFF; PORTC = 0xFF; Delay_ms (1000); PORTB = 0x00; PORTC = 0x00; Delay_ms (1000);
// Parpadeo de los indicadores
PORTB = dirección PORTC = dirección
EEPROM_Read (0x02); 2 y mostrarlos en PORTB EEPROM_Read (0x50); 0x50 y mostrarlos en PORTC
// Escribe algunos datos en la
// para indicar inicio de lectura
// Leer los datos de la // Leer los datos de la
Delay_ms (1000); para (ii = 0; ii <32; ii ++) { de la dirección 0x80 PORTD = EEPROM_Read (0x80 + ii); Delay_ms (250); } }
// Leer el bloque de 32 bytes // y mostrar datos en PORTD
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 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 LCD
El S1D13700 Glcd está diseñado con un generador de caracteres interno que ite 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 iten 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 proyectos utilizando la biblioteca de gráficos Lcd S1D13700:
Descripci ón:
Ejemplo:
extern sfr charS1D13700_DATA;
Bus de datos del sistema.
char S1D13700_DATA atPORTD;
extern sfr sbitS1D13700_WR;
Escribir señal.
sbit S1D13700_WR atLATC2_bit;
extern sfr sbitS1D13700_RD;
Leer la señal.
sbit S1D13700_RD atLATC1_bit;
extern sfr sbitS1D13700_A0;
Dirección del sistema pin.
sbit S1D13700_A0 atLATC0_bit;
extern sfr sbitS1D13700_RES;
Restablece r la señal.
sbit S1D13700_RES atLATC4_bit;
extern sfr sbitS1D13700_CS;
Selección de chip.
sbit S1D13700_CS atLATC4_bit;
extern sfr sbitS1D13700_DATA_Direc tion;
Dirección de los pines del bus de datos del sistema.
sbitS1D13700_DATA_Direction at TRI SD;
extern sfr sbitS1D13700_WR_Directi on;
Dirección del pin de escritura.
sbitS1D13700_WR_Direction at TRISC 2_bit;
extern sfr sbitS1D13700_RD_Directi on;
Dirección del pin de lectura.
sbitS1D13700_RD_Direction at TRISC 1_bit;
extern sfr sbitS1D13700_A0_Directi on;
Dirección del pin de dirección del sistema.
sbitS1D13700_A0_Direction at TRISC 2_bit;
extern sfr sbitS1D13700_RES_Direct ion;
Dirección del pin de reinicio.
sbitS1D13700_RES_Direction at TRIS C0_bit;
extern sfr sbitS1D13700_CS_Directi on;
Dirección del pin de
sbitS1D13700_CS_Direction at TRISC 4_bit;
selección de chip.
Rutinas de la biblioteca
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 glcd. height: Altura del glcd.
Requiere
Variables globales : 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. Debe ser definido antes de usar esta función.
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.
S1D13700_POWER_SAVE
Entrar en modo de ahorro de energía.
S1D13700_DISP_ON
Encienda la pantalla.
S1D13700_DISP_OFF
Apague la pantalla.
S1D13700_SCROLL
Configuración de texto y gráficos de las regiones de dirección.
S1D13700_CS_RIGHT
El cursor se mueve justo después de escribir en la memoria de visualización.
S1D13700_CS_LEFT
El cursor se mueve a la izquierda después de escribir en la memoria de visualización.
S1D13700_CS_UP
El cursor se mueve hacia arriba después de escribir en la memoria de visualización.
S1D13700_CS_DOWN
El cursor se mueve hacia abajo después de escribir en la memoria de visualización.
S1D13700_OVLAY
Configurar cómo se superponen las capas.
S1D13700_CGRAM_ADR
Configurar la dirección RAM del generador de caracteres.
S1D13700_HDOT_SCR
Establecer velocidad de desplazamiento horizontal.
S1D13700_CSRW
Establecer la dirección del cursor.
S1D13700_CSRR
Lea la dirección del cursor.
S1D13700_GRAYSCALE
Selecciona la profundidad de la escala de grises, en bits por píxel (bpp).
S1D13700_MEMWRITE
Escribir para mostrar la memoria.
S1D13700_MEMREAD
Leer de la memoria de la 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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init . 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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
Ejemplo
// borrar el gráfico actual S1D13700_GrFill (0);
S1D13700_TxtFill Prototipo
void S1D13700_TxtFill ( char d);
Devoluciones
Nada.
Descripción
Rellene el de texto actual con el valor apropiado (0 para borrar). Parámetros: d: Este valor se utilizará para rellenar el de texto.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
Ejemplo
// borrar el 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
S1D13700_LAYER_OFF
Desactivar la capa gráfica.
S1D13700_LAYER_ON
Encienda la capa gráfica.
S1D13700_LAYER_FLASH_2Hz
Encienda la capa gráfica y flashéela a una velocidad de 2 Hz.
S1D13700_LAYER_FLASH_16Hz
Encienda la capa gráfica y flashéela a
una velocidad de 16 Hz.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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
S1D13700_LAYER_OFF
Desactivar la capa gráfica.
S1D13700_LAYER_ON
Encienda la capa gráfica.
S1D13700_LAYER_FLASH_2Hz
Encienda la capa gráfica y flashéela a una velocidad de 2 Hz.
S1D13700_LAYER_FLASH_16Hz
Encienda la capa gráfica y flashéela a una velocidad de 16 Hz.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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
S1D13700_CURSOR_UNDERSCORE
Establecer la forma del cursor subrayado.
S1D13700_CURSOR_BLOCK
Establecer la forma del cursor - bloque.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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
S1D13700_CURSOR_OFF
Desactivar la capa gráfica.
S1D13700_CURSOR_ON
Encienda la capa gráfica.
S1D13700_CURSOR_FLASH_2Hz
Encienda la capa gráfica y flashéela a una velocidad de 2 Hz.
S1D13700_CURSOR_FLASH_16Hz
Encienda la capa gráfica y flashéela a una velocidad de 16 Hz.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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). mode:parámetro de modo Valores válidos: Valor
Descripción
S1D13700_OVERLAY_OR
En el modo OR, se pueden mostrar texto y gráficos y los datos están lógicamente "ORed". Esta es la forma más común de combinar texto y gráficos, por ejemplo, etiquetas en botones.
S1D13700_OVERLAY_XOR
En este modo, los datos de texto y gráficos se combinan a través del "OR exclusivo" lógico.<="" td="" style="margin: 0px; padding: 0px;">
S1D13700_OVERLAY_AND
El texto y los datos gráficos que se muestran en la pantalla se combinan a través de la "función AND" lógica.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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 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). mode:parámetro de modo Valores válidos:
Valor
Descripción
S1D13700_OVERLAY_OR
En el modo OR, se pueden mostrar texto y gráficos y los datos están lógicamente "ORed". Esta es la forma más común de combinar texto y gráficos, por ejemplo, etiquetas en botones.
S1D13700_OVERLAY_XOR
En este modo, los datos de texto y gráficos se combinan a través del "OR exclusivo" lógico.<="" td="" style="margin: 0px; padding: 0px;">
S1D13700_OVERLAY_AND
El texto y los datos gráficos que se muestran en la pantalla se combinan a través de la "función AND" lógica.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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 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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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. x1: Coordenada x de la línea de inicio. y1: Coordenada y del final de la línea. pcolor: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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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. pcolor: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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
Ejemplo
S1D13700_Line (0, 0, 239, 127, S1D13700_WHITE);
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. pcolor: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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
Ejemplo
S1D13700_Line (0, 0, 239, 127, S1D13700_WHITE);
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 izquierda del rectángulo. x1: Coordenada x de la esquina inferior derecha del rectángulo. y1: Coordenada y de la esquina inferior derecha del rectángulo. pcolor: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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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. pcolor: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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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 superior izquierda del rectángulo. x_bottom_right: Coordenada x de la esquina inferior derecha del rectángulo. y_bottom_right: Coordenada y de la esquina inferior derecha del rectángulo. round_radius: Radio del borde redondeado. pcolor: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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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: x_upper_left: Coordenada x de la esquina superior izquierda del rectángulo. y_upper_left: Coordenada y de la esquina superior izquierda del rectángulo. x_bottom_right: Coordenada x de la esquina inferior derecha del rectángulo. y_bottom_right: Coordenada y de la esquina inferior derecha del rectángulo. round_radius: Radio del borde redondeado.
pcolor: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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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. 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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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. 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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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.
Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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 (coordenada superior izquierda). 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. 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. Requiere
El módulo Glcd necesita ser inicializado. Ver la rutina S1D13700_Init .
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 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 ite: Protocolo IPv4. Solicitudes de ARP . Solicitudes de eco ICMP . Peticiones UDP Solicitudes de T (sin pila, sin reconstrucción de paquetes). Cliente ARP con caché. Cliente DNS Cliente UDP Cliente DH La fragmentación de paquetes NO es compatible.
Importante: La variable de biblioteca global Ethernet_TimerSecse utiliza para realizar un seguimiento del tiempo para todas las implementaciones de
clientes ( ARP , DNS , UDP y DH ). Es responsabilidad del incrementar esta variable cada segundo en su código si se utiliza alguno de los clientes. Para s 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 , implementadas en la biblioteca Ethernet PIC18FxxJ60.
Rutinas de la biblioteca
Ethernet_Init Ethernet_Enable Ethernet_Disable Ethernet_doPacket Ethernet_putByte Ethernet_putBytes Ethernet_putString Ethernet_putConstString Ethernet_putConstBytes Ethernet_getByte Ethernet_getBytes Ethernet_T Ethernet_UDP Ethernet_getIpAddress Ethernet_getGwIpAddress Ethernet_getDnsIpAddress Ethernet_getIpMask Ethernet_confNetwork Ethernet_arpResolve Ethernet_sendUDP Ethernet_dnsResolve Ethernet_initDH Ethernet_doDHLeaseTime Ethernet_renewDH
Ethernet_Init Prototipo
void Ethernet_Init ( unsigned char * mac, unsigned char * ip, unsigned char fullDuplex);
Devolucione s
Nada.
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 DH , configurarse en 0.0.0.0.
la dirección IP debe
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 nes
Nada.
Descripci ón
Esta es la rutina del módulo MAC . Esta rutina habilita el 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 co
Másc ara
Descripción
Biblioteca predefinida const
0x01
Tráfico de difusión MAC / indicador de filtro de recepción.Cuand o se establece, el tráfi co de transmisión MA C se habilitará.
_Ethernet_BROA DCAST
1
0x02
Tráfico de multidifusión M AC / indicador de filtro de recepción. Cuand o se establece, se habilitará el tráfico de multidifusión M AC .
_Ethernet_MULT ICAST
2
0x04
no utilizado
ninguna
3
0x08
no utilizado
ninguna
4
0x10
no utilizado
ninguna
0
CRC marca de verificación. 5
0x20
6
0x40
Cuando se establece, los paquetes con el campo CRC n o válido se descartarán. no utilizado
_Ethernet_CRC
ninguna
7
0x80
Tráfico de unidifusión MA C / indicador de filtro de recepción.Cuand o se establece, el tráfi co de unidifusión MA C se habilitará.
_Ethernet_UNIC AST
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 nes
Nada.
Descripci ón
Esta es la rutina del módulo MAC . Esta rutina desactiva el 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 filtro. Cada bit corresponde al filtro de tráfico / recepción de red apropiado: Po co
Másc ara
Descripción
Biblioteca predefinida const
0x01
Tráfico de difusión MAC / indicador de filtro de recepción. Cuand o se establece, el tráfi co de transmisión MA C se deshabilitará.
_Ethernet_BROA DCAST
1
0x02
Tráfico de multidifusión M AC / indicador de filtro de recepción. Cuand o se establece, el tráfi co de multidifusión M AC se deshabilitará.
_Ethernet_MULT ICAST
2
0x04
no utilizado
ninguna
3
0x08
no utilizado
ninguna
4
0x10
no utilizado
ninguna
0
CRC marca de verificación. 5
0x20
Cuando se establece, la verificación C RCse deshabilitará y se aceptarán los
_Ethernet_CRC
paquetes con el campo CRC n o válido . 6
7
0x40
no utilizado
ninguna
0x80
Tráfico de unidifusión MA C / indicador de filtro de recepción. Cuand o se establece, el tráfi co de unidifusión MA C se deshabilitará.
_Ethernet_UNIC AST
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 desactivar con esta rutina. 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_Disable (_Ethernet_CRC | _Ethernet_UNICAST); // deshabilitar la comprobación de CRC y el tráfico de unidifusión
Ethernet_doPacket Prototipo Devoluciones
unsigned char Ethernet_doPacket ();
0 - después del procesamiento exitoso de
paquetes (cero paquetes recibidos o recibidos paquete procesado exitosamente).
Descripción
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.
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 T petición del Ethernet_T función se llama para su posterior procesamiento. sobre UDP solicitud la Ethernet_UDP función se llama para su posterior procesamiento. Nota: Ethernet_doPacket debe llamarse tan a menudo como sea posible en el código del .
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
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
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
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.
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
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.
Descripción
Esta es la rutina del módulo MAC . Almacena el número 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 . n: Número de bytes a escribir.
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
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);
memoria RAM del
Devoluciones
Número de bytes escritos en la 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 .
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
char * buffer = "mikroElektronika"; ... 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 controlador Ethernet .
Descripción
Esta es la rutina del módulo MAC . Almacena toda la 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 .
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
const char * buffer = "mikroElektronika"; ... Ethernet_putConstString (búfer); // poner una cadena constante en el búfer del controlador de Ethernet
memoria RAM del
Ethernet_getByte Prototipo
unsigned char Ethernet_getByte ();
Devoluciones
Byte leído desde la Ethernet .
memoria RAM del controlador
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).
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
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.
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
búfer de char [16]; ... Ethernet_getBytes (buffer, 0x100, 16); // leer 16 bytes, comenzando desde la dirección 0x100
Ethernet_T Prototipo
Devoluciones
unsigned int Ethernet_T ( unsigned char * remoteHost, unsigned int remotePort, unsigned int localPort, unsigned int reqLength, TEthPktFlags * flags);
0 - No debe haber una respuesta a la solicitud.
Longitud del campo de datos de respuesta T / HTTP - de lo contrario.
Descripción
Esta es la rutina del módulo T . Se llama internamente por la biblioteca. El accede a la solicitud T / HTTP utilizando algunas de las rutinas Ethernet_get. El 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 T / HTTP , o 0 si no hay nada que transmitir. Si no hay necesidad de responder a las solicitudes T / HTTP , simplemente defina esta función con return (0) como una sola declaración. Parámetros: remoteHost:Dirección IP del cliente . remotePort:puerto T del cliente . localPort: Puerto al que se envía la solicitud. reqLength: Longitud de campo de datos de solicitud T / HTTP . flags: La estructura consistía en dos campos de bits: Copiar código al portapapeles
typedef struct { unsigned canCloseT: 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 para lograr la respuesta deseada. Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
Esta función es llamada internamente por la biblioteca y no debe ser llamada por el código del .
Ethernet_UDP Prototipo
Devoluciones
Descripción
unsigned int Ethernet_UDP ( unsigned char * remoteHost, unsigned int remotePort, unsigned int destPort, unsigned int reqLength, TEthPktFlags * flags);
0 - No debe haber una respuesta a la solicitud.
Longitud del campo de datos de respuesta UDP - de lo contrario.
Esta es la rutina del módulo UDP . Se llama internamente por la biblioteca. El accede a
la solicitud UDP utilizando algunas de las rutinas Ethernet_get. El 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: remoteHost:Dirección IP del cliente . remotePort: Puerto del cliente. destPort: Puerto al que se envía la solicitud. flags: La estructura consistía en dos campos de bits: Copiar código al portapapeles
typedef struct { unsigned canCloseT: 1; // el indicador que cierra el socket T (no relevante para UDP) sin firma 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 para lograr la respuesta deseada. Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
Esta función es llamada internamente por la biblioteca y no debe ser llamada por el código del .
Ethernet_getIpAddress Prototipo
unsigned char * Ethernet_getIpAddress ();
Devoluciones
Puntero a la variable global con dirección
Descripción
Esta rutina debe usarse cuando el servidor DH está presente en la red para obtener la dirección IP asignada .
IP .
Nota: El 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 en ningún caso!
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
unsigned char ipAddr [4]; // búfer de direcciones IP de ... memy (ipAddr, Ethernet_getIpAddress (), 4); // obtener la dirección IP
Ethernet_getGwIpAddress Prototipo
unsigned char * Ethernet_getGwIpAddress ();
Devoluciones
Puntero a la variable global que contiene de la puerta de enlace .
Descripción
Esta rutina debe usarse cuando el servidor DH está presente en la red para obtener la dirección IP de lapuerta de enlace asignada .
la dirección IP
Nota: El 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 de puerta de enlace . ¡Estas ubicaciones no deben ser alteradas por el en ningún caso! Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
unsigned char gwIpAddr [4]; // búfer de direcciones IP de la puerta de enlace del ... memy (gwIpAddr, Ethernet_getGwIpAddress (), 4); // obtener la dirección IP de la puerta de enlace
Ethernet_getDnsIpAddress (); Prototipo
unsigned char * Ethernet_getDnsIpAddress
Devoluciones
Puntero a la variable global que contiene del DNS .
Descripción
Esta rutina se debe usar cuando el servidor DH está presente en la red para obtener la dirección IPasignada del DNS .
la dirección IP
Nota: El 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 de DNS . ¡Estas ubicaciones no deben ser alteradas por el en ningún caso!
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
unsigned char dnsIpAddr [4]; // búfer de dirección IP de DNS ... memy (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 subred IP .
Descripción
Esta rutina debe usarse cuando el servidor DH está presente en la red para recuperar la máscara de subred IP asignada .
la máscara de
Nota: El siempre debe copiar la dirección IP de la ubicación de RAM que devuelve esta rutina en su propio búfer de máscara de subred IP . ¡Estas ubicaciones no deben ser alteradas por el en ningún caso! Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
unsigned char IpMask [4]; // búfer de máscara de subred IP de ... memy (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 DH 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 DH . De lo contrario, DH anulará esta configuración. Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
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
Devoluciones
Descripción
unsigned char * Ethernet_arpResolve ( unsigned char * ip, unsigned char tmax);
MAC dirección detrás de la IP Address - La solicitado IP dirección se resolvió.
0 de lo contrario
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.
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
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
Devoluciones
unsigned char Ethernet_sendUDP ( unsigned char * destIP, unsigned int sourcePort, unsigned int destPort, unsigned char * pkt, unsigned intpktLen);
1- El paquete UDP fue enviado exitosamente. 0 de lo contrario
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.
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
unsigned char IpAddr [4] = {192, 168, 1, 1}; // 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
Devoluciones
unsigned char * Ethernet_dnsResolve ( unsigned char * host, unsigned char tmax);
Descripción
puntero a la ubicación donde se encuentra la dirección IP : se resolvió el nombre de host solicitado. 0 de lo contrario
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. tmax: tiempo en segundos para esperar una respuesta.
Los parámetros de red mencionados anteriormente deben configurarse con esta rutina solo si no se utiliza el módulo DH . De lo contrario, DH 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 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 en ningún caso!
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
unsigned char * remoteHostIpAddr [4]; // búfer de direcciones IP del host del ... // 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 memy (remoteHostIpAddr, Ethernet_dnsResolve ("swisstime.ethz.ch", 5), 4);
Ethernet_initDH Prototipo
Devoluciones
Descripción
unsigned char Ethernet_initDH ( unsigned char tmax);
1 - Los parámetros de red se obtuvieron
exitosamente. 0 de lo contrario
Esta es la rutina del módulo DH . Envía una solicitud DH para los parámetros de red ( IP , puerta de enlace, direcciones DNS y máscara de subred IP ) y espera la respuesta de DH . 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 DH y el puerto UDP67 se utiliza como puerto de servidor DH . Parámetros: tmax: tiempo en segundos para esperar una respuesta.
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. Cuando se usa el módulo DH , la variable de biblioteca global Ethernet_TimerSecse usa para mantener un registro del tiempo. Es responsabilidad del incrementar esta variable cada segundo en su código.
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
... Ethernet_initDH (5); // obtener la configuración de red del servidor DH, espere 5 segundos para obtener la respuesta ...
Ethernet_doDHLeaseTime Prototipo Devoluciones
unsigned char Ethernet_doDHLeaseTime ();
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 DH . 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 ar al servidor DH y renovar el contrato de arrendamiento.
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
mientras (1) { ... if (Ethernet_doDHLeaseTime ())
... // es hora de renovar el arrendamiento de la dirección IP }
Ethernet_renewDH Prototipo
unsigned char Ethernet_renewDH ( 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 DH . Envía la solicitud de renovación del tiempo de concesión de la dirección IP al servidor DH . Parámetros: tmax: tiempo en segundos para esperar una respuesta.
Requiere
El módulo de Ethernet tiene que ser inicializado. Ver Ethernet_Init .
Ejemplo
mientras (1) { ... if (Ethernet_doDHLeaseTime ()) Ethernet_renewDH (5); // es hora de renovar el arrendamiento de la dirección IP, con 5 segundos para una respuesta ... }
Ejemplo de biblioteca 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 : / 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. Copiar código al portapapeles
#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 ">
Mini servidor web PIC18FxxJ60 1t1g2
Recargar <script src = / s>
ADC |
AN2 |
<script>document.write(AN2) |
AN3 |
<script>document.write(AN3) |
|
PORTB |
<script> var str, i; str = ""; para (i = 0; i <8; i ++) {str + = "
BUTTON #" + i + " | "; if (PORTB & (1 << i)) {str + = "
ON";} else else {str + = " |
OFF";} str + = " |
";} document.write (str); "; const char * indexPage2 = "
|
PORTD |
<script> var str, i; str = ""; para (i = 0; i <3; i ++) {str + = "
LED #" + i + " | "; if (PORTD & (1 << i)) {str + = "
ON";} else else {str + = " |
OFF";} str + = " |
Toggle |
";} document.write (str);
|
Esta es la solicitud HTTP # <script> document.write (REQ)