TODOPIC
Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: Limbo en 17 de Junio de 2013, 16:55:07
-
Buenas,
Llevo exactamente dos dias investigando el tema y no saco nada en claro en cuanto a los lenguajes de programacion en C, me refiero, todos los compiladores usan directivas y funciones diferentes..¿que sentido tiene? Significa que tengo que centrarme en un compilador unicamente? He probado mikroC y me compila perfecto, lo he montado en proto y perfecto, pero luego CCS es absolutamente diferente a mikroC en cuanto a codigo. Ahora mismo estoy probando el XC8 y me da que es diferente a los otros dos, porque no me compila, me da errores por todos lados..
¿Que podeis aconsejarme? ¿Por donde empiezo? Sé programar en C y en asembler..
MikroC lo descarto porque tiene un bug con la { y me sale comentario en la misma linea.
La cuestion es que este año haré en clase programacion en C para pics, y por eso me preocupa aprender algo que no me sirva despues en clase..
Gracias.
Saludos.
-
XC8 es la continuación de PICC y el que ahora soporta Microchip.
Es arriesgado, porque es muy nuevo y no existe todavía mucho soporte para el, pero se parece mucho al PICC y al C18 (antiguo compilador C de microchip)
Cualquiera de estos es un compilador "serio" que te servirá para futuros desarrollos (por ejemplo son los únicos con los que podrás utilizar los sistemas operativos de tiempo real, RTOS, más conocidos). Además tienen versiones Freeware por las que no tienes que pagar.
CCS te sirve para programar rápido porque tiene muchas librerías para empezar con todo ya hecho, pero no es un c tan estandar como el de los anteriores y al parecer tiene bastantes bugs. Además es de pago.
Saludos.
-
Concuerdo con picuino, yo en particular recomendaría xc8 ya que es a donde se encamina microchip además que tiene la versión gratuita, ccs es bueno tambien pero es poco portátil tiene bugs y es de paga, xc8 trabaja con Ansi C ósea se estándar que es mas portable, además xc8 es mas profesional. Mi opinión.
Saludos
-
Hola Limbo, mira, tambien anduve en la mísma situación que Vos, me decidi por el CCS, por que al principio era el único que me funcionaba, hoy no lo cambio...
Hay un dato importante de este compilador, es que te abstrae del hardware, y con ello sacas muy rápido tus proyectos, no tenés que conocer tan finamente al micro que programas y sus "modulos". Efectivamente como te indicaron trae una cantidad de librerias y programas de ejemplos, acorta increiblemente los tiempos de aprendizaje y desarrollo de los proyectos, es como un "arduino".
Los demás compiladores, intentan ser compiladores apegandose a un estandard, con esto logras portabilidad, pero en su afan de esta "portabilidad", debes empezar a conocer de cerca el hardware que estas programando.
Si Vos conoces Assembler, es fácil de entender lo que te decimos, personalmente con el CCS, me pongo loco por no tener el control de las interrupciones por ejemplo. Pero en desarrollos simples, sale airoso, sin transmitirte dudas.
-
XC8 es la continuación de PICC y el que ahora soporta Microchip.
Es arriesgado, porque es muy nuevo y no existe todavía mucho soporte para el, pero se parece mucho al PICC y al C18 (antiguo compilador C de microchip)
Cualquiera de estos es un compilador "serio" que te servirá para futuros desarrollos (por ejemplo son los únicos con los que podrás utilizar los sistemas operativos de tiempo real, RTOS, más conocidos). Además tienen versiones Freeware por las que no tienes que pagar.
CCS te sirve para programar rápido porque tiene muchas librerías para empezar con todo ya hecho, pero no es un c tan estandar como el de los anteriores y al parecer tiene bastantes bugs. Además es de pago.
Saludos.
El XC8 es identico al C18 solo que con otro nombre (y algunas otras modificaciones nuevas que le habran puesto), lo mismo ocurre con todos los compiladores de microchip c30 = xc16, c32=xc32... ambos son copias identicas solo que le habran puesto las mejoras que le hubiesen puesto a los viejos compiladores si no les hubiesen "cambiado el nombre". Todo esto lo digo porque cuando salieron las nuevas versiones compile y el codigo era exactamente identico.
Sobre la cuestion del creador del tema:
-Yo empece con CCS pero no me gusto mucho, como dices no tiene nada que ver con el resto, ademas, tampoco controlas mucha parte del codigo ya que la mayoria lo hace por funciones.
-Luego me pase a mikroC y me gusto bastante mas, sin embargo necesitaba algo mas, soy de los que le gusta controlar todo la parte del codigo asi que me pase a los compiladores de microchip, aparte que puedes complicar cualquier pic por muy nuevo que sea de cualquier familia, sin embargo en los demas compiladores tendrias que esperar a que saliese la nueva version para poder usar los pics nuevos que hayan salido, incluso ni eso.
-XC8, XC16, XC32: sin duda, lo mejor que he probado para los pics, es un poco complejo al principio, pero una vez te acostumbras es muy sencillo y tienes el 100% del control del codigo, sin bugs ni nada.
-
tendría que haberme cruzado con esta página hace un par de meses....
http://www.cursomicros.com/pic/programacion-de-microcontroladores-pic.html
-
Primero que todo, gracias por las contestaciones.
Bueno, por lo que leo, el control total lo tienes con los compiladores de microchip (Me gusta no dejar cabos sueltos), ahora bien, el C18 solo puedes programar serie 18 o puedes programar tambien 12 y 16?
Estoy trabajando con el 16F886 y el año que viene seguiremos trabajando con ese, si no vale el C18, ¿Cual uso? ¿Hi tech?
Estoy como una lechuga en un matadero, perdido totalmente.. :D Aunque avanzo poco a poco.. a ver si saco algo en claro..
-
Primero que todo, gracias por las contestaciones.
Bueno, por lo que leo, el control total lo tienes con los compiladores de microchip (Me gusta no dejar cabos sueltos), ahora bien, el C18 solo puedes programar serie 18 o puedes programar tambien 12 y 16?
Estoy trabajando con el 16F886 y el año que viene seguiremos trabajando con ese, si no vale el C18, ¿Cual uso? ¿Hi tech?
Estoy como una lechuga en un matadero, perdido totalmente.. :D Aunque avanzo poco a poco.. a ver si saco algo en claro..
El C18 ya digamos que se quedo "obsoleto" ahora se utiliza el XC8, con este podras usar cualquier pic de la familia de 8bits (10f,12f,16f,18f....), anteriormente el C18 era solo para pic18 para lo demas se usaba hitech
-
Lei mas arriba que XC8y C18 son practicamente iguales, entonces ¿Puedo usar un manual de C18 para XC8?
-
Si, pero porque no mejor usar un manual de XC8?? :lol:
http://ww1.microchip.com/downloads/en/DeviceDoc/52053B.pdf
-
Primero que todo, gracias por las contestaciones.
Bueno, por lo que leo, el control total lo tienes con los compiladores de microchip (Me gusta no dejar cabos sueltos), ahora bien, el C18 solo puedes programar serie 18 o puedes programar tambien 12 y 16?
Estoy trabajando con el 16F886 y el año que viene seguiremos trabajando con ese, si no vale el C18, ¿Cual uso? ¿Hi tech?
Estoy como una lechuga en un matadero, perdido totalmente.. :D Aunque avanzo poco a poco.. a ver si saco algo en claro..
Ten en cuenta que para PIC pequeños, como los PIC16 y series menores, se programa siempre en ensamblador, por cuestión de espacio, además el XC8 gratuito no activa la optimización, con lo que el tamaño del objeto puede llegar a ser el doble del que tendría optimizado. Te vas a dar de bruces si tratas de programar en C los PIC16, salvo que lo quieras para hacer cuatro chuminadas caseras, como encender un LED y similares.
O te pasas a PIC18, o compras la versión profesional de XC8 para programar los PIC16, y aún así, yo no lo haría, la diferencia de tamaño del objeto programando la misma aplicación en ensamblador o en C, es considerable, eso se puede obviar cuando trabajas con 128K o más de flash, pero esos tamaños de flash no los vas a encontrar en un pic16. De hecho la serie de compiladores de Microchip, C18, C30 y C32, no contemplaba los PIC16 e inferiores, por algo sería.
Con PIC18, también podrías bajarte una versión full del C18, de emule, y trabajar con la optimización activada, o compras el XC8 que es barato, por 495 dólares lo tienes en MicrochipDirect. Desgraciadamente los que trabajamos con PIC32, lo tenemos más crudo, el XC32 cuesta nada menos que 1445 dólares, yo sigo con C32 que también se puede usar desde MPLAB-X y tan feliz.
-
La idea de pasarme ha programar en C viene porque en ensamblador controlar LCD es mas complicado, y con mikroC lo hice en un momento..
Os explico, estoy haciendo un superior de electronica y en este curso hemos programado ensamblador usando el pic16f886, al acabar el curso nos dijeron que en segundo año se haria programacion en C para los pics, y queria adelantar un poco materia a la vez que sacio la ansiedad :-/ :-/ No sé ni que pic usaremos, ni que compilador... Deduje que usariamos el pic16f886 porque es el que hemos estado usando hasta ahora e ensamblador.. por eso estoy con los 16F, no por nada mas..
De momento quiero aprender a programar pics en C, hacer ejercicios y eso, sobretodo para contorlar una LCD y con XC8 puedo trabajar con pics de 8bits, asi que me servira si subo a la serie 18..
La idea era aprender C para programar pics de manera generica, pero esto es un desastre de estandarizacion, hay mil y un compiladores..
Sigo sin aclararme :oops: :? Pero creo que continuaré con xc8, aunque tengo en cuenta lo de la memoria... para lo que quiero hacer, que son programas de aprendizaje me vendra bien, creo...
Merlinz me refiero a un tutorial de aprendizaje de C18 usarlo con XC8
-
Por aquí en el foro busca mini curso xc8 no te pongo el link porque estoy desde un móvil pero ahí están poniendo varios ejemplitos con xc8
-
Programar en asm para ahorrar espacio de programa sólo merece la pena si vas a ahorrarte mucho dinero en los pic (por ejemplo si vas a programar cientos de micros iguales) porque el trabajo extra que lleva programar en asm no compensa un ahorro de uno o dos euros que cuesta un microcontrolador mayor.
También para ciertas rutinas muy específicas, puede ser útil programar en asm para que sean más rápidas o que tengan mayor control sobre el micro. Son raras excepciones y se pueden combinar sin problemas con C.
En el resto de ocasiones, el C sin dudas es la mejor opción.
El compilador gratuíto que mejor optimiza, de todos los que conozco para PIC16, es el CC5X: http://www.bknd.com/cc5x
No es ANSI C, pero eso es en ocasiones una ventaja. Por ejemplo las funciones no son reentrantes, utilizan variables estáticas y eso hace que sean muy rápidas y se ejecuten con poco código. No necesitan el manejo de pila que utilizan otros compiladores y que aumentan el tamaño de programa y ralentizan el programa.
En cuanto a la optimización de la RAM, sin duda el C vuelve a ser la mejor opción.
Saludos.
-
La idea de pasarme ha programar en C viene porque en ensamblador controlar LCD es mas complicado, y con mikroC lo hice en un momento..
Os explico, estoy haciendo un superior de electronica y en este curso hemos programado ensamblador usando el pic16f886, al acabar el curso nos dijeron que en segundo año se haria programacion en C para los pics, y queria adelantar un poco materia a la vez que sacio la ansiedad :-/ :-/ No sé ni que pic usaremos, ni que compilador... Deduje que usariamos el pic16f886 porque es el que hemos estado usando hasta ahora e ensamblador.. por eso estoy con los 16F, no por nada mas..
Las series pequeñas se suelen trabajar en ensamblador, por cuestiones de espacio, en 1K, 2K, 4k poco vas a poder meter si te pones a programar en C, y encima con la versión gratuita de XC8 que no optimiza el objeto. Lo lógico será que si empezais a programar en C, os pongan al menos los PIC18, ya lo verás.
De momento quiero aprender a programar pics en C, hacer ejercicios y eso, sobretodo para contorlar una LCD y con XC8 puedo trabajar con pics de 8bits, asi que me servira si subo a la serie 18..
Para hacer prácticas sencillas, te vale la versión gratuita.
La idea era aprender C para programar pics de manera generica, pero esto es un desastre de estandarizacion, hay mil y un compiladores..
No hay tantos, los de Microchip, el de Mikroelektronika y el CCS.
Si lees el foro, verás que la gente que trabaja con CCS, se queja de la cantidad de bugs que tiene ese compilador.
Los productos de Mikrolektronika, yo los distribuí en España hace unos años (en 2004-2005 creo recordar), las placas entrenadoras, las vendía bastante a escuelas de Formación Profesional, de los compiladores vendí algunos de C y Pascal, en general son buenos productos, pero yo prefiero los originales de Microchip. La mayoría de la web de Mikroelektronika en español, se las traduje yo, hasta ese momento lo tenían todo en inglés y no tenían distruidor en España (y ahora siguen sin tenerlo desde que yo dejé la distribución).
Sigo sin aclararme :oops: :? Pero creo que continuaré con xc8, aunque tengo en cuenta lo de la memoria... para lo que quiero hacer, que son programas de aprendizaje me vendra bien, creo...
Pues no es tan dificil, para la serie pequeña hasta PIC16, usa XC8, siempre y cuando sea para cosas sencillas, o compra la versión profesional para optimizar el tamaño del objeto, se reduce casi a la mitad con la optimización al máximo nivel, tienes un nivel superior de optimización que aumenta algo el tamaño pero mejora el rendimiento.
Para PIC18, puedes trabajar con C18, tienes versiones full en Emule, con las que puedes activar la optimización.
Para PIC24 y PIC32, los compiladores XC son muy caros, prefiero usar C30 y C32, usar el XC gratuito para estas series es absurdo, salen unos objetos enormes en comparación a la compilación optimizada.
-
Ya me va quedando más claro. Hoy he pasado toda la tarde intentando hacer andar una libreria LCD y no ha habido forma de ver una palabra en la pantalla :oops: :( He probado la xlcd que viene con XC8, me baje un par más de internet y nada, quizas sea una pregunta repetida pero ¿Me recomendais algun tutorial mascadito para usar una libreria LCD en XC8? De verdad, est anoche lo deje aburrido, despues de horas dandole he acabado desesperado.. ¿Me hechais una mano? :mrgreen: :-/
-
Todo lo que se va comentando en este tema te puede ser util
http://www.todopic.com.ar/foros/index.php?topic=40649.0
-
Yo he programado el PIC16F883 (7kb de programa) con el compilador CC5X y da mucho juego (puedes realizar programas relativamente grandes sin problemas de espacio).
Con el XC8 no lo he probado todavía, porque prefiero trabajar de forma habitual con PIC18. Normalmente tiene memoria de sobra para los desarrollos que hago, pero así me vale el mismo micro para el día que tenga que hacer un programa mayor. La diferencia de precio es pequeña.
Para que tengas una idea, el último programa que he hecho en C con 1500 líneas de código (contando espacios y comentarios) ocupa una memoria de programa de 8Kbytes compilado con XC8 sin optimizar.
El programa es bastante grande como para hacer un montón de cosas con el y el 16f886 tiene más memoria todavía.
Si te decides por el compilador CC5X, es poco conocido y poco estandar, pero tiene la ventaja de que si lo manejas bien, te compila cada línea de C en una o dos líneas de ensamblador. Es muy eficiente incluso en la versión gratuita. Los otros compiladores como el XC8 meten un montón de líneas de código en el paso de argumentos a las funciones. Por ejemplo para pasar un caracter a una función, el CC5X lo manda mediante el registro de trabajo WREG, mientras que otros compiladores pasan el argumento mediante una pila, con bastantes líneas de ASM para una cosa tan sencilla.
Saludos.
-
Todo lo que se va comentando en este tema te puede ser util
http://www.todopic.com.ar/foros/index.php?topic=40649.0
Ya le he hechado un ojo a ese tema
Para que tengas una idea, el último programa que he hecho en C con 1500 líneas de código (contando espacios y comentarios) ocupa una memoria de programa de 8Kbytes compilado con XC8 sin optimizar.
No creo que haga más de 1500 lineas..
Creo que me quedare con XC8, eso si, si consigo hacer funcionar la libreria LCD :D Se me resiste. Esta tarde volvere a la carga.
-
¿Puedes poner un esquema de las conexiones al lcd?
Tengo una librería que podría ayudarte en el caso de que utilices la conexión a 4 bits.
Saludos
-
No lo guarde el esquema, pero vamos, lo conecte como indicaba en la libreria, la alimentacion tambien estaba bien conectada, lo unico que tenia dudas era en los 4bits de datos.. si conectarlos seguidos a los otros 3 (RS,RW,E) o conectarlos en los bits altos.. estoy casi seguro que el codigo estaba mal...
No tengo mucha experiencia con LCD, hice lo justo en ensamblador y usabamos 8bits pero veo que la mayoria usa 4 bits... alguna ventaja tendra, voy a leer un poco sobre eso ahora mismo..
¿Si me la puedes pasar la libreria LCD? ¿o decirme de donde la descargo? Una cosa, ¿la XLCD nadie la usa?no veo mucha info en internet..
-
Los LCD son muy sencillos, simplemente deberias buscarte algun sitio donde te lo expliquen correctamente (algun tutorial) y seguro que te resulta muy sencillo, los glcd por ejemplo se complican algo mas, pero una vez ves como van pues te resulta bastante sencillo. Ahora que te vas a pasar a C tienes varias librerias a tu disposicion y con un simple comando puedes escribir facilmente en el lcd sin tener que escribir mil lineas en asm.
La ventaja de 8bits vs 4bits es que son 4 cables en vez de 8 y reduce mucho las conexiones y utilizacion de pines.
-
Los LCD son muy sencillos, simplemente deberias buscarte algun sitio donde te lo expliquen correctamente (algun tutorial)
Eso es lo qu eno encuentro para CX8..
-
buscalo para C18, como indico xc8 es un c18, todo lo que tengas para c18 vale para xc8, si no encuentras mucho para xc8 es porque ha salido hace poco y entonces no hay muchos tutoriales.
-
yo estoy ahora mismo instalando el XC8 free...
no se pueden adaptar librerias que por ejemplo tiene el compilador ccs a xc8?
-
Esta es la rutina que yo utilizo.
Sirve para enviar datos al LCD con 4 bits de ancho que también se utilizan para leer pulsadores.
El esquema es el siguiente:
https://sites.google.com/site/picuino/_/rsrc/1324213759944/picuino-18f2550/lcd_display/Schematic_v11.png
(https://sites.google.com/site/picuino/_/rsrc/1324213759944/picuino-18f2550/lcd_display/Schematic_v11.png?width=600)
El código para manejarlo es:
/*
LCD AND KEYBOARD MANAGE ROUTINES
*/
#include <p18cxxx.h>
#include "lcd_keyb.h"
#include "config.h"
#include "delays.h"
/****************************************************************************
HARDWARE DEFINITIONS
****************************************************************************/
//#define LCD_PORTA
#ifndef LCD_PORTA
#define LCD_PORTB
#endif
#ifdef LCD_PORTB
#define LCD_E LATBbits.LATB2 // LCD CONTROL BIT. Enable
#define LCD_RS LATBbits.LATB3 // LCD CONTROL BIT. Control/data mode
#define LCD_D4 LATBbits.LATB4 // LCD DATA BIT
#define LCD_D5 LATBbits.LATB5 // LCD DATA BIT
#define LCD_D6 LATBbits.LATB6 // LCD DATA BIT
#define LCD_D7 LATBbits.LATB7 // LCD DATA BIT
#define KEYB_KB1 PORTBbits.RB4
#define KEYB_KB2 PORTBbits.RB5
#define KEYB_KB3 PORTBbits.RB6
#define KEYB_KB4 PORTBbits.RB7
#define LCD_TRIS_DATA_OUT() TRISB &= 0b00001111
#define LCD_TRIS_DATA_IN() TRISB |= 0b11110000
#define LCD_TRIS_CONTROL_OUT() TRISB &= 0b11110011
#elif defined LCD_PORTA
#define LCD_E LATAbits.LATA0 // LCD CONTROL BIT. Enable
#define LCD_RS LATAbits.LATA1 // LCD CONTROL BIT. Control/data mode
#define LCD_D4 LATAbits.LATA2 // LCD DATA BIT
#define LCD_D5 LATAbits.LATA3 // LCD DATA BIT
#define LCD_D6 LATAbits.LATA4 // LCD DATA BIT
#define LCD_D7 LATAbits.LATA5 // LCD DATA BIT
#define KEYB_KB1 PORTAbits.RA2
#define KEYB_KB2 PORTAbits.RA3
#define KEYB_KB3 PORTAbits.RA4
#define KEYB_KB4 PORTAbits.RA5
#define LCD_TRIS_DATA_OUT() TRISA &= 0b11000011
#define LCD_TRIS_DATA_IN() TRISA |= 0b00111100
#define LCD_TRIS_CONTROL_OUT() TRISA &= 0b11111100
#endif
/****************************************************************************
DATA DEFINITIONS
****************************************************************************/
typedef union {
unsigned char byte;
struct {
unsigned b0:1;
unsigned b1:1;
unsigned b2:1;
unsigned b3:1;
unsigned b4:1;
unsigned b5:1;
unsigned b6:1;
unsigned b7:1;
};
} tbyte;
/****************************************************************************
DELAY ROUTINES
****************************************************************************/
/*
Active delay of 20us
F_OSC (frequency of working oscillator) must be defined
*/
void Delay_20us(void) {
#if F_OSC == 4000000
Delay10TCYx(2-1);
#elif F_OSC == 8000000
Delay10TCYx(4-1);
#elif F_OSC == 12000000
Delay10TCYx(6-1);
#elif F_OSC == 16000000
Delay10TCYx(8-1);
#elif F_OSC == 20000000
Delay10TCYx(10-1);
#elif F_OSC == 24000000
Delay10TCYx(12-1);
#elif F_OSC == 48000000
Delay10TCYx(24-1);
#else
#error F_OSC not recognized
#endif
}
/*
Active delay of 1us*time
with error of several TCY
*/
void Delay_ms(unsigned int time) {
do {
#if F_OSC == 4000000
Delay100TCYx(10);
#elif F_OSC == 8000000
Delay100TCYx(20);
#elif F_OSC == 12000000
Delay100TCYx(30);
#elif F_OSC == 16000000
Delay100TCYx(40);
#elif F_OSC == 20000000
Delay100TCYx(50);
#elif F_OSC == 24000000
Delay100TCYx(60);
#elif F_OSC == 48000000
Delay100TCYx(120);
#else
#error F_OSC not recognized
#endif
} while(--time);
}
/****************************************************************************
KEYBOARD ROUTINES
****************************************************************************/
/*
Read keyboard and return result.
Side efects:
Disable analog inputs (ADCON1).
Change data pin as inputs.
Disable Pull-up resistors (PORTB option)
Return:
if key1 pressed bit 0 = 1;
if key2 pressed bit 1 = 1;
if key3 pressed bit 2 = 1;
if key4 pressed bit 3 = 1;
*/
unsigned char kb_read(void) {
tbyte kb;
#ifdef LCD_PORTB
// Disable all PORTB pull-ups
INTCON2bits.RBPU = 1;
#endif
// Change all pins to digital inputs
ADCON1 = 0b00001111;
// Charge capacitors
LCD_TRIS_DATA_OUT();
LCD_D4 = LCD_D5 = LCD_D6 = LCD_D7 = 1;
Delay_20us();
// Read keyboard
LCD_TRIS_DATA_IN();
kb.byte = 0;
if (KEYB_KB1==0) kb.b0 = 1;
if (KEYB_KB2==0) kb.b1 = 1;
if (KEYB_KB3==0) kb.b2 = 1;
if (KEYB_KB4==0) kb.b3 = 1;
// Test if keyboard is disconected (all inputs == 1)
if (kb.byte == 0b00001111) {
return 0;
}
// Return keys pressed
return kb.byte;
}
/****************************************************************************
LCD ROUTINES
****************************************************************************/
/*
INITIALIZE LCD IN 4-BIT MODE AND SET PREFERENCES
*/
void lcd_init(void) {
// Init data pins
LCD_D4 = 0;
LCD_D5 = 0;
LCD_D6 = 0;
LCD_D7 = 0;
LCD_TRIS_DATA_OUT();
// Init control pins
LCD_TRIS_CONTROL_OUT();
LCD_RS = 0; // LCD IN CONTROL MODE
LCD_E = 0;
//Delay_ms(25) ; // Wait for more than 20 ms after Vdd rises to 4.5 V
// Reset procedure through software
lcd_putctrl(0b00110000); // 8 bits mode
Delay_ms(5);
lcd_putctrl(0b00110000); // 8 bits mode
Delay_ms(5);
lcd_putctrl(0b00110010); // 4 bits mode
Delay_ms(5);
// CONFIGURE LCD
lcd_putctrl(0b00101000); // 001 = FUNCTION SET.
// 0 = 4 BIT INTERFACE
// 1 = 2 LINES
// 0 = 5x8 DOTS, x, x
lcd_putctrl(0b00001000); // 00001 = DISPLAY CONTROL. 0=DISPLAY OFF, 1=CURSOR ON, 1=CURSOR BLINK OFF, x
lcd_putctrl(0b00001100); // 00001 = DISPLAY CONTROL. 1=DISPLAY ON, 1=CURSOR ON, 1=CURSOR BLINK OFF, x
lcd_clear();
lcd_putctrl(0b00000110); // 000001 = ENTRY MODE. CURSOR MOVE INCREMENT, DO NOT SHIFT DISPLAY
lcd_putctrl(0b00010100); // 0001 = CURSOR-DISPLAY. 0=MOVE CURSOR, 1=SHIFT RIGHT, x, x
lcd_goto(0);
}
/*
Clears entire display and sets DDRAM address 0 in address
counter
*/
void lcd_clear(void) {
lcd_putctrl(0b00000001); // CLEAR DISPLAY.
Delay_ms(2); // Execution time > 1.6 ms
}
/*
Sets DDRAM address 0 in address counter. Also returns
display from being shifted to original position. DDRAM
contents remain unchanged
*/
void lcd_home(void) {
lcd_putctrl(0b00000010); // CURSOR TO POSITION 0
Delay_ms(2); // Execution time > 1.6 ms
}
/*
Set address of cursor in LCD
Send addr to DDRAM address register
*/
void lcd_goto(unsigned char x) {
lcd_putctrl(0b10000000 + x); // CURSOR TO POSITION x
}
/*
Send control code to LCD
*/
void lcd_putctrl(unsigned char c) {
LCD_TRIS_DATA_OUT();
LCD_RS = 0; // LCD IN CONTROL MODE
lcd_putbyte(c);
LCD_TRIS_DATA_IN();
}
/*
Send character to LCD
*/
void lcd_putc(unsigned char c) {
LCD_TRIS_DATA_OUT();
LCD_RS = 1; // LCD IN DATA MODE
lcd_putbyte(c);
LCD_TRIS_DATA_IN();
}
/*
Send string from rom to LCD
*/
void lcd_puts(const char *str) {
while(*str) {
lcd_putc(*str);
str++;
}
}
/*
Send string from ram to LCD
*/
void lcd_puts_ram(char *str) {
while(*str) {
lcd_putc(*str);
str++;
}
}
void lcd_putbyte(unsigned char c) {
LCD_E = 0;
lcd_putnibble(c);
lcd_putnibble(c<<4);
}
/*
Send high nibble of character 'c' to LCD
*/
void lcd_putnibble(unsigned char c) {
tbyte C;
LCD_D4 = 0;
LCD_D5 = 0;
LCD_D6 = 0;
LCD_D7 = 0;
C.byte = c;
if (C.b4==1) LCD_D4 = 1;
if (C.b5==1) LCD_D5 = 1;
if (C.b6==1) LCD_D6 = 1;
if (C.b7==1) LCD_D7 = 1;
lcd_enable();
}
/*
ENABLE LCD
Send enable signal to LCD
*/
void lcd_enable(void) {
// Enable signal must be set 1us min
LCD_E = 1;
Delay_20us();
LCD_E = 0;
Delay_20us();
}
En ocasiones da problemas la inicialización del LCD. Creo que es un problema de tiempos. En cualquier caso el 99% de las veces funciona OK.
Página del proyecto (con código para C18):
https://sites.google.com/site/picuino/picuino-18f2550/lcd_display
Saludos.
-
Si quieres aprender te recomiendo que te olvides de librerias, seguramente el curso que estas haciendo no te dejen usar librerias porque le quita toda la gracia a la enseñanza, una vez ya sepas como funciona todo pues a usar librerias o incluso hacerlas tu mismo.
-
Pero esa rutina es para pic18 y yo estoy usando la serie 16... la probare igualmente intentado adaptarla.. muchas gracias.
Estoy leyendome el manual de Suky que esta en pdf y copiando el ejemplo de libreria XLCD que tiene me salta un error que me dice que no estan definidas las funciones de la libreria... :5]:
0: error: undefined symbols:
_WriteCmdXLCD(dist/default/production\tuto_C18.X.production.obj) _putrsXLCD(dist/default/production\tuto_C18.X.production.obj) _OpenXLCD(dist/default/production\tuto_C18.X.production.obj) _BusyXLCD(dist/default/production\tuto_C18.X.production.obj)
(908) exit status = 1
Pero esas funciones deben estar definidas en alguna libreria de las que vienen por defecto no?¿
-
Para que tengas una idea, el último programa que he hecho en C con 1500 líneas de código (contando espacios y comentarios) ocupa una memoria de programa de 8Kbytes compilado con XC8 sin optimizar.
No creo que haga más de 1500 lineas..
Creo que me quedare con XC8, eso si, si consigo hacer funcionar la libreria LCD :D Se me resiste. Esta tarde volvere a la carga.
[/quote]
Hola Limbo ...yo logre hacer funcionar una libreria lcd en cx8 , por el port b y el a de un pic16f819 esta en el curso de xc8 con el dsn de proteus ...mirala te va a servir ...despues de eso le meti un i2c por soft ...y al quererle meter una libreria de un sensor de presion me quede sin memoria ...el pic tiene 3,5 k ....y con el xc8 sin optimizar me comio todo ...aparte de eso me ha vuelto loco con los problemas ...la verdad me estoy arrepintiendo de este compiler ....ojo es mi opinion ...soy nuevo en C ...y lo que veo que en Hi-Tech ..hay mas soluciones en la red ...tambien en CCS pero dicen que tiene muchos bugs ...de hi-tech tambien podes conseguir por emule o ares el full
Bueno esa es mi opinion ..
Un Abrazo
-
En microcontroladores PIC16/18 es todo un tema, a pesar de trabajar en un lenguaje de alto nivel, casi todo lo que se hace requiere trabajar mucho a nivel hardware, y los compiladores existentes lo trabajan de forma diferente. Cuando comienzas a utilizar microcontroladores de mayores capacidades, encaras proyectos mas complejos y podes separar con mas facilidad lo que es a nivel hardware y lo que es de alto nivel, y allí solo te dedicas a programar en C. No es una obligación, pero es una buena practica. Te vas a dar cuento de esto cuando le des un vistazo a los RTOS, donde esto se pone en practica.
Volviendo a los peques, PIC16/18, lo mejor es utilizar el compilador que mas cómodo y mejores resultados no de, se va a resolver el proyecto en menos tiempo y de buena manera, generalmente. Mi recomendación es utilizar un compilador de sea ANSI C, así no nos acostumbramos a malas practicas de programación, que después cuando tengamos que migrar nos va a dar dolores de cabeza :mrgreen:
Saludos!
-
Hola Limbo ...yo logre hacer funcionar una libreria lcd en cx8 , por el port b y el a de un pic16f819 esta en el curso de xc8 con el dsn de proteus ...mirala te va a servir ...despues de eso le meti un i2c por soft ...y al quererle meter una libreria de un sensor de presion me quede sin memoria ...el pic tiene 3,5 k ....y con el xc8 sin optimizar me comio todo
El que yo uso tiene 14k, yo creo que me aguanta un poco más..
Si me estoy dando cuenta que no para de darme errores el compilador, a todo momento jaja Pero al ser de microchip quiero seguir intentandolo.. Aunque la facilidad que me dio mikroC gana muchos puntos.. tiene un error al poner "}" y me comenta la linea, no me mate mucho a buscar por google y me pase directamente a probar con XC8, pero creo que intentare buscar solucion al error ese.. ¿Que opinais de mikroC?
Volviendo a los peques, PIC16/18, lo mejor es utilizar el compilador que mas cómodo y mejores resultados no de, se va a resolver el proyecto en menos tiempo y de buena manera, generalmente. Mi recomendación es utilizar un compilador de sea ANSI C, así no nos acostumbramos a malas practicas de programación, que después cuando tengamos que migrar nos va a dar dolores de cabeza
Eso es lo que principalmente me preocupa, aprender cosas que quizas en un futuro no me sirvan.. Me he leido el manual casi entero de Suky y no quiero seguir avanzando si no es el compilador que voy a usar... ya lo he dicho anteriormente, y no quiero ser pesado, pero, este compilador se queja demasiado jajaja que si me falta una ruta... que si no esta definida la funcion... que sii... que si.. que si... jajaja en fin, en cambio con mikroC todo va super suave, no da tanto errores, a la primera consegui hacer funcionar la LCD..
Otra vez tengo la lucha mental; ¿Me quedo con XC8? jaja Voy a leer sobre mikroC a ver como es..
Gracias por todo :mrgreen: