Mini curso "Programación en XC8"

[AngelGris]

Gracias compañero por el aporte.. 
   Veo que estas mas familiarizado que yo en esto.

   Preguntas:
        1.  declare bien los puertos?
        2.  como hago para "invocar" el valor almacenado en la variable contador?
             
             

  1) ¿A que te refieres con "declare bien los puertos"? Si te refieres a que si están bien configurados, todo dependerá de tus necesidades. En este ejemplo en particular que sólo necesitas RC0 como entrada, sí está bien el valor del registro TRISC

  2) No entiendo que quieres decir con invocar. Si quieres compararlo con otro valor y otra variable es tan fácil como hacer algo así

Código: C

1. if (contador != variable) // si contador distinto de variable
2. o
3. if (contador > 50) // si contador mayor a 50

[Rojasfx]

Si con declarar puertos me refiero configurarlos es que lo que deseo es precionar un pulsador y que el contador vaya contando y este numero verlo en un display de 7 segmentos
  y que cuando el  contador llegue a cierto numero digamos 9 se resete y comienze de nuevo

Un asunto que le he estado dando y no entiendo porque me señala erron la linea __delay_ms (15); salen varios errores al copilar como que falta un ) y que error de sintaxis y ya defini el oscilador.. no entiendo porque..

[luisccl]

alguien podria decirme donde encontrar nuevamente el turorial de suky acerca de PIC 18, que el link de la pagina mencionado en todos los post esta caido de hace muchos dias, y al parecer nadie dice nada al respecto

[AngelGris]

  Subo una librería para LCD 2x16. Está basada en una que había hecho anteriormente para HiTech, sólo que esta vez cuenta con una función para crear caracteres y se puede utilizar con o sin el pin RW. Sólo la simulé en ISIS y funcionó bien, y como la versión anterior hubo gente del foro que la utilizó, imagino que ésta versión tendrá que funcionar también.

xclcd.h

Código: C

1. #ifndef XCLCD_H
2. #define XCLCD_H
3.  
4. #ifndef _XC_H_
5. #include <xc.h>
6. #endif
7.  
8. /******************************************************************************
9.  *  Parametros configurables por el usuario                                   *
10.  ******************************************************************************/
11.  
12. /*
13.  * El valor de _XTAL_FREQ debe coincidir con el valor definido
14.  * en el programa principal
15.  */
16.  
17. /*
18.  * LCDEN define el pin EN para el lcd
19.  * LCDRS define el pin RS para el lcd
20.  * LCDRW define el pin RW para el lcd
21.  * LCDDATA define el puerto de datos
22.  */
23.  
24. /*
25.  * Si se utiliza un pic con resgistros LAT
26.  * se pueden definir los pines utilizando LAT<x>bits.LAT<x><y>
27.  * siendo <x> la letra del puerto correspondiente y <y> el bit
28.  * Tambien se puede definir de la misma manera el puerto de datos
29.  */
30.  
31. /*
32.  * LCDTRISEN define el bit TRIS para el pin EN
33.  * LCDTRISRS define el bit TRIS para el pin RS
34.  * LCDTRISRW define el bit TRIS para el pin RW
35.  * LCDTRIS define el TRIS correspondiente al puerto de datos
36.  */
37.  
38. /*
39.  * PROTOCOL4BIT define si se utiliza protocolo de 4 bits
40.  * PROTOCOL8BIT define si se utiliza protocolo de 8 bits
41.  */
42.  
43. /*
44.  * En caso de utilizar protocolo de 4 bits
45.  * UPPER define si se utiliza el nibble alto del puerto
46.  * LOWER define si se utiliza el nibble bajo del puerto
47.  */
48.  
49. /*
50.  * En caso de utilizar el pin RW, hay que definir
51.  * USE_RW
52.  */
53.  
54. #ifndef _XTAL_FREQ
55. #define _XTAL_FREQ 20000000
56. #endif
57.  
58. #define LCDEN PORTBbits.RB0
59. #define LCDRS PORTBbits.RB1
60. #define LCDRW PORTBbits.RB2
61. #define LCDTRISEN TRISBbits.TRISB0
62. #define LCDTRISRS TRISBbits.TRISB1
63. #define LCDTRISRW TRISBbits.TRISB2
64. #define LCDDATA PORTB
65. #define LCDTRIS TRISB
66. #define PROTOCOL4BIT
67. #define UPPER
68. #define USE_RW
69.  
70.  
71. /******************************************************************************
72.  *  Definicion de valores para lcd_setdisplay                                 *
73.  ******************************************************************************/
74. /*
75.  * Los valores se pueden combinar utilizando el operador |
76.  */
77.  
78. #define DISPLAY_OFF 0b00001000
79. #define DISPLAY_ON  0b00001100
80. #define CURSOR_OFF  0b00001100
81. #define CURSOR_ON   0b00001110
82. #define BLINK_OFF   0b00001100
83. #define BLINK_ON    0b00001101
84.  
85. /******************************************************************************
86.  *  Definicion de valores para lcd_shift                                      *
87.  ******************************************************************************/
88. /*
89.  * Los valores se pueden combinar utilizando el operador |
90.  */
91.  
92. #define SHIFT_DISPLAY 0b00011000
93. #define SHIFT_CURSOR  0b00010000
94. #define SHIFT_LEFT    0b00010000
95. #define SHIFT_RIGHT   0b00010100
96.  
97. /******************************************************************************
98.  *  Definicion de valores para lcd_entrymode                                  *
99.  ******************************************************************************/
100. /*
101.  * Los valores se pueden combinar utilizando el operador |
102.  */
103.  
104. #define INCREMENT 0b00000110
105. #define DECREMENT 0b00000100
106. #define SHIFT_ON  0b00000101
107. #define SHIFT_OFF 0b00000100
108.  
109.  
110. /******************************************************************************
111.  *  Definicion de funciones                                                   *
112.  ******************************************************************************/
113.  
114. void lcd_init(void);
115. void lcd_put(unsigned char, unsigned char);
116. void lcd_puts(const unsigned char*);
117. void lcd_gotoxy(unsigned char, unsigned char);
118. bit lcd_busy(void);
119. void lcd_putini(unsigned char);
120. void lcd_createchar(unsigned char, const unsigned char*);
121. void lcd_setdisplay(unsigned char);
122. void lcd_shift(unsigned char);
123. void lcd_entrymode(unsigned char);
124.  
125. #define lcd_putch(x) lcd_put(x,1)
126. #define lcd_clear() lcd_put(0x01,0)
127. #define lcd_home() lcd_put(0x02,0)
128. #define lcd_off() lcd_put(0x08,0)
129. #define lcd_on() lcd_put(0x0C,0)
130.  
131. #endif  /* XCLCD_H */

xclcd.c

Código: C

1. #include "xclcd.h"
2.  
3. #if !defined(LCDEN) || !defined(LCDRS)
4. #error Faltan definir los pines de control
5. #elif !defined(LCDTRISEN) || !defined(LCDTRISRS)
6. #error Falta definir la direccion de los pines de control
7. #elif !defined(LCDDATA) || !defined(LCDTRIS)
8. #error Falta definir el puerto y/o el tris de datos
9. #elif !defined(PROTOCOL4BIT) && !defined(PROTOCOL8BIT)
10. #error Falta definir el protocolo
11. #elif defined(PROTOCOL4BIT) && !defined(UPPER) && !defined(LOWER)
12. #error Falta definir el nibble
13. #else
14.  
15. void lcd_init(void)
16. {
17.     unsigned char veces;
18.  
19.     LCDEN = 0;
20.     LCDRS = 0;
21.     LCDRW = 0;
22.     LCDTRISRS = 0;
23.     LCDTRISRW = 0;
24.     LCDTRISEN = 0;
25.     __delay_ms(15);
26.     for (veces = 3; veces > 0; veces--)
27.     {
28.     lcd_putini(0x30);
29.     __delay_ms(5);
30.     }
31. #if defined(PROTOCOL8BIT)
32.     lcd_put(0x38,0);                          // Dos lineas, caracter 5x8
33. #elif defined(PROTOCOL4BIT)
34.     lcd_putini(0x20);                         // Protocolo de 4 bits
35.     lcd_put(0x28,0);                          // Dos lineas, caracter 5x8
36. #endif
37.     lcd_put(0x08,0);                          // Apagar display, cursor, blink
38.     lcd_put(0x01,0);                          // Borrar display
39.     lcd_put(0x06,0);                          // Incrementa posicion, sin shift
40. }
41.  
42. void lcd_putini(unsigned char data)
43. {
44.     unsigned char lasttris;
45.  
46.     lasttris = LCDTRIS;
47. #if defined(PROTOCOL8BIT)
48.     LCDTRIS = 0;
49.     LCDDATA = data;
50. #elif defined(PROTOCOL4BIT)
51. #if defined(UPPER)
52.     LCDTRIS &= 0x0F;
53.     LCDDATA = (LCDDATA & 0x0F) | data;
54. #elif defined(LOWER)
55.     LCDTRIS &= 0xF0;
56.     data = data >> 4;
57.     LCDDATA = (LCDDATA & 0xF0) | data;
58. #endif
59. #endif
60.     LCDEN = 1;
61.     __delay_us(1);
62.     LCDEN = 0;
63.     LCDTRIS = lasttris;
64. }
65.  
66. void lcd_put(unsigned char data, unsigned char reg)
67. {
68.     unsigned char lasttris;
69.  
70.     lasttris = LCDTRIS;
71. #if defined (USE_RW)
72.     while(lcd_busy() == 1);
73. #else
74.     __delay_ms(2);
75. #endif
76.     LCDRS = reg;
77.     LCDRW = 0;
78. #if defined(PROTOCOL8BIT)
79.     LCDTRIS = 0;
80.     LCDDATA = data;
81.     LCDEN = 1;
82.     __delay_us(1);
83.     LCDEN = 0;
84. #elif defined(PROTOCOL4BIT)
85. #if defined(UPPER)
86.     LCDTRIS &= 0x0F;
87.     LCDDATA = (LCDDATA & 0x0F) | (data & 0xF0);
88.     LCDEN = 1;
89.     __delay_us(1);
90.     LCDEN = 0;
91.     __delay_us(1);
92.     LCDDATA = (LCDDATA & 0x0F) | (data << 4);
93.     LCDEN = 1;
94.     __delay_us(1);
95.     LCDEN = 0;
96. #elif defined(LOWER)
97.     LCDTRIS &= 0xF0;
98.     LCDDATA = (LCDDATA & 0xF0) | (data >> 4);
99.     LCDEN = 1;
100.     __delay_us(1);
101.     LCDEN = 0;
102.     __delay_us(1);
103.     LCDDATA = (LCDDATA & 0xF0) | (data & 0x0F);
104.     LCDEN = 1;
105.     __delay_us(1);
106.     LCDEN = 0;
107. #endif
108.  
109. #endif
110.     LCDTRIS = lasttris;
111. }
112.  
113.  
114. bit lcd_busy(void)
115. {
116.     unsigned char lasttris;
117.     unsigned char busy;
118.  
119.     lasttris = LCDTRIS;
120.     LCDRS = 0;
121.     LCDRW = 1;
122. #if defined(PROTOCOL8BIT)
123.     LCDTRIS = 0xFF;
124.     LCDEN = 1;
125.     __delay_us(1);
126.     busy = LCDDATA;
127.     LCDEN = 0;
128. #elif defined(PROTOCOL4BIT)
129. #if defined(UPPER)
130.     LCDTRIS = (LCDTRIS & 0x0F) | 0xF0;
131.     LCDEN = 1;
132.     __delay_us(1);
133.     busy = LCDDATA;
134.     LCDEN = 0;
135.     __delay_us(1);
136.     LCDEN = 1;
137.     __delay_us(1);
138.     LCDEN = 0;
139. #elif defined(LOWER)
140.     LCDTRIS = (LCDTRIS & 0xF0) | 0x0F;
141.     LCDEN = 1;
142.     __delay_us(1);
143.     busy = LCDDATA << 4;
144.     LCDEN = 0;
145.     __delay_us(1);
146.     LCDEN = 1;
147.     __delay_us(1);
148.     LCDEN = 0;
149. #endif
150. #endif
151.     LCDTRIS = lasttris;
152.     if ((busy & 0x80) == 0x80) return 1;
153.     else
154.         return 0;
155. }
156.  
157. void lcd_gotoxy(unsigned char x, unsigned char y)
158. {
159.     x--;
160.     y--;
161.     if (y == 0) lcd_put((0x80 + x),0);
162.     else
163.         lcd_put((0xC0 + x),0);
164. }
165.  
166. void lcd_puts(const unsigned char* st)
167. {
168.     while (*st != 0)
169.     {
170.         lcd_put(*st,1);
171.         st++;
172.     }
173. }
174.  
175. void lcd_createchar(unsigned char asciicode, const unsigned char* ascii)
176. {
177.     unsigned char line;
178.     unsigned char caracter;
179.  
180.     for (line = 0; line < 7; line++)
181.     {
182.         caracter = ((asciicode & 0x07) << 3) | 0x40 + line;
183.         lcd_put(caracter,0);
184.         lcd_put(*ascii,1);
185.         ascii++;
186.     }
187.     caracter = ((asciicode & 0x07) << 3) | 0x47;
188.     lcd_put(caracter,0);
189.     lcd_put(0,1);
190.     lcd_clear();
191. }
192.  
193. void lcd_setdisplay(unsigned char state)
194. {
195.     lcd_put(state,0);
196. }
197.  
198. void lcd_shift(unsigned char state)
199. {
200.     lcd_put(state,0);
201. }
202.  
203. void lcd_entrymode(unsigned char state)
204. {
205.     lcd_put(state,0);
206. }
207. #endif

[AngelGris]

  Y aquí un programa de ejemplo. En este ejemplo definí el caracter ñ y muestro la palabra "Pequeño" y "Pequeno" para ver como queda el caracter representado en el LCD.

Código: C

1. #include <xc.h>
2.  
3. #pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator: High-speed crystal/resonator on RA6/OSC2/CLKOUT and RA7/OSC1/CLKIN)
4. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
5. #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
6. #pragma config MCLRE = OFF      // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is digital input, MCLR internally tied to VDD)
7. #pragma config BOREN = OFF      // Brown-out Detect Enable bit (BOD disabled)
8. #pragma config LVP = OFF        // Low-Voltage Programming Enable bit (RB4/PGM pin has digital I/O function, HV on MCLR must be used for programming)
9. #pragma config CPD = OFF        // Data EE Memory Code Protection bit (Data memory code protection off)
10. #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
11.  
12. #define _XTAL_FREQ 20000000
13.  
14. #include "xclcd.h"
15.  
16. void main(void)
17. {
18.     unsigned char alfa[17] = "Peque";
19.     const unsigned char letra[8] = {0b00000000,
20.                                     0b00001110,
21.                                     0b00000000,
22.                                     0b00010110,
23.                                     0b00011001,
24.                                     0b00010001,
25.                                     0b00010001};
26.     unsigned char veces;
27.  
28.     CMCON = 7;
29.     PORTA = 0;
30.     TRISA = 0;
31.     PORTB = 0;
32.     TRISB = 0;
33.     lcd_init();
34.     lcd_createchar(1,letra);
35.     lcd_setdisplay(DISPLAY_OFF);
36.     lcd_puts("Pequeno");
37.     lcd_gotoxy(1,2);
38.     lcd_puts(alfa);
39.     lcd_putch(1);
40.     lcd_putch('o');
41.     lcd_gotoxy(1,1);
42.     lcd_setdisplay(CURSOR_ON);
43.     while(1);
44. }

[Miquel_S]

Gracias AngelGris por el aporte, ahora me toca estudiar.

  QUE ENVIDIA me conformaria con saber una parte de lo que sabeis la mayoria de vosotros.

Miquel_S

[AngelGris]

  Comparto tu opinión, que bueno sería saber aunque sea una mínima parte de lo que saben Nocturno, RedPic, Suky, Picuino y tantos otros... uno los sigue desde atrás pero en lugar de acortar la distancia, ésta se estira cada vez más 

[rotting79]

here is another library for LCD 2 x 16 on  XC8, may be helpful....

http://www.todopic.com.ar/foros/index.php?topic=41874.msg348245#msg348245

[freshdesing]

TIMER 1 y TIMER 2 con 16F876A:

main.c

Código: C

1. /******************************************************************************/
2. /* Files to Include
3.  *
4.  * *****   TIMER 1   *****
5.  * 16 bit  2x8bit TMR1H y TMR1L  0000h -> FFFFh
6.  *
7.  * TMR1ON: Star-Stop TIMER 1
8.  * TMR1CS: Clock Source Timer/Counter
9.  *      -T1SYNC: Syncronizacion
10.  * T1OSCEN: enable-disable TIMER 1
11.  * TMR1IE : Flag de interrupción
12.  * T1CKPS1:T1CKPS0: Prescaler (1,2,4,8) -> Se borra al escribir en TMR1H o TMR1L
13.  *
14.  * (Registro PIR1)
15.  * TMR1IF: Flag Overflow -> Borrar por software
16.  *
17.  * (Registro PIE1)
18.  * TMR1IE: Enable interrupt TIMER 1
19.  *
20.  * (Registro INTCON)
21.  * GIE: Activar interrupciones golobales
22.  * PEIE: Activar interrupciones de perifericos
23.  *
24.  * Cuando esta funcionando: RC1 y RC0 son SALIDAS
25.  *
26.  * Interrupcion=4*TOSC*(65535-TMR1)*PRESCALER
27.  *
28.  *
29.  * *****   TIMER 2   *****
30.  * 8 bit  PR2 00h -> FFh
31.  * Cuenta de 00h a PR2
32.  * (Registro T2CON)
33.  * TMR2ON: Star-Stop TIMER 2  (T2CON)
34.  * T2CKPS1:T2CKPS0: Prescaler (1,4,16)
35.  * TOUTPS3:TOUTPS0: Poscaler (1...16)
36.  *
37.  * (Registro PIR1)
38.  * TMR2IF: Flag Overflow -> Borrar por software
39.  *
40.  * (Registro PIE1)
41.  * TMR2IE: Enable interrupt TIMER 2
42.  *
43.  * (Registro INTCON)
44.  * GIE: Activar interrupciones golobales
45.  * PEIE: Activar interrupciones de perifericos
46.  * Interrupcion=4*TOSC*(255-PR2)*PRESCALER*POSCALER
47.  *
48.  *
49.  */
50. /******************************************************************************/
51. /* Interrupcion cada 100ms con el TIMER 1 (TMR1=53035)  LED RB0
52. /* Interrupcion cada 50ms con el TIMER 2 (PR2=60) LED RB1
53. /******************************************************************************/
54.  
55.  
56. #include <xc.h>         /* XC8 General Include File */
57.  
58. #include <stdio.h>
59. #include <stdint.h>        /* For uint8_t definition */
60. #include <stdbool.h>       /* For true/false definition */
61.  
62.  
63. #include "user.h"          /* User funct/params, such as InitApp */
64. #include "configuration_bits.c"
65. //#include "interrupts.c"
66.  
67. #define _XTAL_FREQ 4000000 // Indicamos a que frecuencia de reloj esta funcionando el micro
68. //#include <p16f876x.h>
69. #define LED_B0 PORTBbits.RB0
70. #define LED_B1 PORTBbits.RB1
71. /******************************************************************************/
72. /* User Global Variable Declaration  */
73.  
74.  
75. /******************************************************************************/
76.  
77. /* i.e. uint8_t <variable_name>; */
78.  
79. void interrupt high_isr(void)
80.     {
81.     //Interrupcion TIMER 1
82.     if(PIR1bits.TMR1IF == 1)
83.         {
84.         LED_B0 ^= 1;
85.         TMR1H = 0xCF; // TIMER1 = 53035
86.         TMR1L = 0x2B;
87.         PIR1bits.TMR1IF = 0;      // Limpiamos bandera de desborde
88.         }
89.  
90.     //Interrupcion TIMER 2
91.     if(PIR1bits.TMR2IF == 1)
92.         {
93.         LED_B1 ^= 1;
94.         PR2 = 195; //TIMER2 = 195
95.         PIR1bits.TMR2IF = 0;      // Limpiamos bandera de desborde
96.         }
97.  
98.     }
99.  
100.  
101.  
102.  
103.  
104.  
105.  
106.  
107. /******************************************************************************/
108. /* Main Program                                                               */
109. /******************************************************************************/
110.  
111.     // FUNCION PRINCIPAL
112. void main () {
113.    TRISB = 0;                   // Puerto B como salidas
114.    PORTB = 0;
115.  
116.    // Configuración del timer & interrupcion
117.    
118.    //Configuracion TIMER 1
119.    T1CONbits.TMR1CS = 0 ;   //Internal Clock
120.    T1CONbits.T1CKPS0 = 1;   //Prescaler = 8
121.    T1CONbits.T1CKPS1 = 1;
122.    PIE1bits.TMR1IE = 1;     //Habilitar interrupcion TIMER 1
123.    PIR1bits.TMR1IF = 0;      // Limpiamos bandera de desborde
124.    T1CONbits.TMR1ON = 1;    //TIMER 1 ON
125.  
126.    //Configuracion TIMER 2
127.    T2CONbits.T2CKPS1 = 1;    //Prescaler = 16
128.    T2CONbits.TOUTPS0 = 1;    //Postcale = 16
129.    T2CONbits.TOUTPS1 = 1;
130.    T2CONbits.TOUTPS2 = 1;
131.    T2CONbits.TOUTPS3 = 1;
132.    PIE1bits.TMR2IE = 1;     //Habilitar interrupcion TIMER 2
133.    PIR1bits.TMR2IF = 0;      // Limpiamos bandera de desborde
134.    T2CONbits.TMR2ON = 1;    //TIMER 2 ON
135.  
136.    //Configuracion interrupciones
137.    INTCONbits.PEIE = 1;     //Peripheral Interrupt Enable bit
138.    INTCONbits.GIE = 1;      //Global Interrupt Enable bit
139.  
140.  
141.  
142.  
143.  
144.    
145.  
146.  
147.  
148.    // Bucle infinito
149.    while (1)
150.    {
151.  
152.        
153.    }
154. }

configuration_bits.c

Código: C

1. /******************************************************************************/
2. /* Main Files to Include                                                      */
3. /******************************************************************************/
4.  
5.  
6. #include <xc.h>         /* XC8 General Include File */
7.  
8.  
9. /******************************************************************************/
10. /* Configuration Bits                                                         */
11. /*                                                                            */
12. /* Refer to your Hi-Tech User Manual in the PICC installation directory       */
13. /* /doc folder for more information on filling in configuration bits.         */
14. /* In addition, configuration bit mnemonics can be found in your              */
15. /* PICC\version\include\<processor name>.h file for your device.  The XC8     */
16. /* compiler contains documentation on the configuration bit macros within     */
17. /* the compiler installation /docs folder in a file called                    */
18. /* pic18_chipinfo.html.                                                       */
19. /*                                                                            */
20. /* For additional information about what the hardware configurations mean in  */
21. /* terms of device operation, refer to the device datasheet.                  */
22. /*                                                                            */
23. /* A feature of MPLAB X is the 'Generate Source Code to Output' utility in    */
24. /* the Configuration Bits window.  Under Window > PIC Memory Views >          */
25. /* Configuration Bits, a user controllable configuration bits window is       */
26. /* available to Generate Configuration Bits source code which the user can    */
27. /* paste into this project.                                                   */
28. /*                                                                            */
29. /******************************************************************************/
30.  
31. /* TODO Fill in your config bits here.  Use the configuration bits generator/ */
32. #include <xc.h>         /* XC8 General Include File */
33. #include <stdint.h>        /* For uint8_t definition */
34. #include <stdbool.h>       /* For true/false definition */
35. #include <pic16f876a.h>
36.  
37.  
38. // PIC16F876A Configuration Bit Settings
39. #pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
40. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
41. #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
42. #pragma config BOREN = ON       // Brown-out Reset Enable bit (BOR enabled)
43. #pragma config LVP = OFF        // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
44. #pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
45. #pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
46. #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

Cualquier mejora sera bienvenida.

Un saludo.

[Joe86]

Hola a todos, soy nuevo en el foro, ni siquiera sabía que ahora hay que decir que tiempo es el que se va estar dentro del Foro jejeje... He leído las respuestas y preguntas que muchos de ustedes han realizado a través de este tema, y Woao, no se, mi duda en algunos puntos se han aclarado, por ejemplo en los "Fuses" que no sabía que había que declararlos, yo vengo de Proton IDE y tengo ya más de 3 años que no agarro un PIC para programar, y simplemente por el uso de Software libre quise intentarlo usando las herramientas necesarias que existen para Ubuntu, cosa que MPLAB me suena bastante interesante y amigable, como bien dicen, se parece mucho a NetBeans para Java. En fin, lo único que busco es hacer un pequeño contador que muestre en 3 displays 7 segmentos, pero como quiero un PIC pequeño, procuro utilizar un Decodificador para ahorrarme unas patas del microcontrolador. Entonces mi gran duda es, por que cuando trato de activar un pin del microcontrolador a través de una variable, asignándole su respectiva posición, el compilador me da error?. Intento realizar algo como así:

char numeros[10] = {0,1,2,3,4,5,6,7,8,9};
char numero, i ;
numero = numeros ;

PORTBbits.RB0 = numero.0 ;
PORTBbits.RB1 = numero.1 ;
PORTBbits.RB2 = numero.2 ;
PORTBbits.RB3 = numero.3 ;

Esto debido a que numero debe ir cambiando ya que solo utilizo un solo decodificador y 3 displays, debido que la cifra más grande a mostrar posee 3 unidades, desde 0 a 250. No tengo todo el programa terminado, pero simplemente quería saber si el compilador no me daba error cuando trataba de modificar un bit del puerto del microcontrolador, pero no puedo hacerlo desde una variable, si me pudieran orientar mejor?, porque no recuerdo sinceramente si desde PROTON en Basic se podía realizar dicha modificaciones. O es que a juro necesito decirle que el valor es 0 o 1 para poder modificar el valor del pin del microcontrolador?... Gracias...

[sander]

Hola a todos, soy nuevo en el foro, ni siquiera sabía que ahora hay que decir que tiempo es el que se va estar dentro del Foro jejeje... He leído las respuestas y preguntas que muchos de ustedes han realizado a través de este tema, y Woao, no se, mi duda en algunos puntos se han aclarado, por ejemplo en los "Fuses" que no sabía que había que declararlos, yo vengo de Proton IDE y tengo ya más de 3 años que no agarro un PIC para programar, y simplemente por el uso de Software libre quise intentarlo usando las herramientas necesarias que existen para Ubuntu, cosa que MPLAB me suena bastante interesante y amigable, como bien dicen, se parece mucho a NetBeans para Java. En fin, lo único que busco es hacer un pequeño contador que muestre en 3 displays 7 segmentos, pero como quiero un PIC pequeño, procuro utilizar un Decodificador para ahorrarme unas patas del microcontrolador. Entonces mi gran duda es, por que cuando trato de activar un pin del microcontrolador a través de una variable, asignándole su respectiva posición, el compilador me da error?. Intento realizar algo como así:

char numeros[10] = {0,1,2,3,4,5,6,7,8,9};
char numero, i ;
numero = numeros ;

PORTBbits.RB0 = numero.0 ;
PORTBbits.RB1 = numero.1 ;
PORTBbits.RB2 = numero.2 ;
PORTBbits.RB3 = numero.3 ;

Esto debido a que numero debe ir cambiando ya que solo utilizo un solo decodificador y 3 displays, debido que la cifra más grande a mostrar posee 3 unidades, desde 0 a 250. No tengo todo el programa terminado, pero simplemente quería saber si el compilador no me daba error cuando trataba de modificar un bit del puerto del microcontrolador, pero no puedo hacerlo desde una variable, si me pudieran orientar mejor?, porque no recuerdo sinceramente si desde PROTON en Basic se podía realizar dicha modificaciones. O es que a juro necesito decirle que el valor es 0 o 1 para poder modificar el valor del pin del microcontrolador?... Gracias...

Eso de numero.0 no es correcto en C, En el compilador XC8 se puede realizar PORTBbits.RB0 porque el compilador tiene definido PORTBbits como estructura, para poder acceder a los bits de una variable de forma similar a la que se accede a los pines del micro debe definir la variable de la siguiente forma:

Código: C

1. union
2. {
3.     char value;
4.     struct
5.     {
6.         unsigned bit0:1;
7.         unsigned bit1:1;
8.         unsigned bit2:1;
9.         unsigned bit3:1;
10.         unsigned bit4:1;
11.         unsigned bit5:1;
12.         unsigned bit6:1;
13.         unsigned bit7:1;
14.  
15.     }bits;
16.  
17. }numero;

Una vez definida la variable de esa manera puede acceder a ella de la siguiente forma:

Código: C

1. numero.value = numeros[i];
2. PORTBbits.RB0 = numero.bits.bit0;

[AngelGris]

  Librería para manejo de teclado... Está pensada para teclado telefónico y Hexa. El puerto de las filas es la entrada y el de las columnas es la salida.
  La idea de funcionamientos es que primeramente están todas las salidas activas, para poder evaluar si hay alguna tecla presionada. Dentro de la función KBDGetKey() se hace un barrido secuencial de las columnas. Sólo una columna a la vez queda configurada como salida, el resto se configura como entrada para evitar posibles problemas.

xckbd.h

Código: C

1. #ifndef XCKBD_H
2. #define XCKBD_H
3.  
4.   #ifndef _XC_H_
5.     #include <xc.h>
6.   #endif
7.   #include <stdint.h>
8.  
9.  /*****************************************************************************
10.   *  Disposicion de los diferentes teclados                                   *
11.   *****************************************************************************
12.  
13.   *****************************************************************************
14.   *           PHONE_KEYPAD                        HEXA_KEYPAD                 *
15.   *****************************************************************************
16.   *        Out0   Out1   Out2                Out0   Out1   Out2   Out3        *
17.   *          |      |      |                   |      |      |      |         *
18.   *         ---    ---    ---                 ---    ---    ---    ---        *
19.   *   In0--| 1 |--| 2 |--| 3 |          In0--| 0 |--| 1 |--| 2 |--| 3 |       *
20.   *         ---    ---    ---                 ---    ---    ---    ---        *
21.   *          |      |      |                   |      |      |      |         *
22.   *         ---    ---    ---                 ---    ---    ---    ---        *
23.   *   In1--| 4 |--| 5 |--| 6 |          In1--| 4 |--| 5 |--| 6 |--| 7 |       *
24.   *         ---    ---    ---                 ---    ---    ---    ---        *
25.   *          |      |      |                   |      |      |      |         *
26.   *         ---    ---    ---                 ---    ---    ---    ---        *
27.   *   In2--| 7 |--| 8 |--| 9 |          In2--| 8 |--| 9 |--| A |--| B |       *
28.   *         ---    ---    ---                 ---    ---    ---    ---        *
29.   *          |      |      |                   |      |      |      |         *
30.   *         ---    ---    ---                 ---    ---    ---    ---        *
31.   *   In3--| * |--| 0 |--| # |          In3--| C |--| D |--| E |--| F |       *
32.   *         ---    ---    ---                 ---    ---    ---    ---        *
33.   *                                                                           *
34.   *****************************************************************************/
35.  
36.  
37.   /****************************************************************************
38.    *  Parametros configurables por el usuario                                 *
39.    ****************************************************************************/
40.  
41.   /* Definir los puertos a utilizar */
42.   #define KBD_COLUMN_PORT PORTB
43.   #define KBD_ROW_PORT    PORTA
44.  
45.   /* Definir los TRIS correspondientes a los puertos utilizados */
46.   #define KBD_COLUMN_TRIS TRISB
47.   #define KBD_ROW_TRIS    TRISA
48.  
49.   /* Descomentar una de las siguientes lineas segun el teclado utilizado */
50.   #define KBD_HEXA_KEYPAD
51.   //#define KBD_PHONE_KEYPAD
52.  
53.  
54.   /* Segun se utilicen resistencias de pullup o pulldown en el puerto de
55.      las filas, descomentar la linea correspondiente */
56.   //#define USE_KBD_PULLUP_RESISTOR
57.   #define USE_KBD_PULLDOWN_RESISTOR
58.  
59.   /* Descomentar una de las siguientes lineas segun el nibble utilizado
60.      para las filas */
61.   #define USE_KBD_ROW_LOWER_NIBBLE
62.   //#define USE_KBD_ROW_UPPER_NIBBLE
63.  
64.   /* Descomentar una de las siguientes lineas segun el primer bit utilizado
65.      para las columnas */
66.   //#define USE_KBD_FIRST_COLUMN_BIT 0
67.   //#define USE_KBD_FIRST_COLUMN_BIT 1
68.   #define USE_KBD_FIRST_COLUMN_BIT 4
69.   //#define USE_KBD_FIRST_COLUMN_BIT 5
70.  
71.  
72.   /****************************************************************************
73.    *  Definicion de funciones                                                 *
74.    ****************************************************************************/
75.  
76.   /*
77.    * Inicializa los puertos para el teclado
78.    */
79.   void KBDInit(void);
80.  
81.   /*
82.    * Devuelve 1 si hay alguna tecla presionada, o 0 si no hay tecla presionada
83.    */
84.   bit KBDIsKeyHit(void);
85.  
86.   /*
87.    * Devuelve el codigo ascci de la tecla presionada
88.    */
89.   uint8_t KBDGetKey(void);
90.  
91.   /*
92.    * Activa todas las salidas
93.    */
94.   void KBDSetColumn(void);
95.  
96. #endif  /* XCKBD_H */

xckbd.c

Código: C

1. #include "xckbd.h"
2. #if !defined(KBD_ROW_PORT) || !defined(KBD_COLUMN_PORT)
3.   #error Falta definir los puertos
4. #else
5.  
6.   /*
7.    * Inicializa los puertos para el teclado
8.    */
9.   void KBDInit(void)
10.   {
11. #if defined(USE_KBD_ROW_LOWER_NIBBLE)
12.       KBD_ROW_TRIS |= 0x0F;
13. #elif defined(USE_KBD_ROW_UPPER_NIBBLE)
14.       KBD_ROW_TRIS |= 0xF0;
15. #endif
16. #if defined(KBD_HEXA_KEYPAD)
17. #if (USE_KBD_FIRST_COLUMN_BIT == 0)
18.   #define KBD_COLUMN_TRIS_MASK 0xF0
19.   #define KBD_COLUMN_DATA_MASK 0x0F
20.   #define KBD_FIRST_BIT_MASK 0x01
21. #elif (USE_KBD_FIRST_COLUMN_BIT == 4)
22.   #define KBD_COLUMN_TRIS_MASK 0x0F
23.   #define KBD_COLUMN_DATA_MASK 0xF0
24.   #define KBD_FIRST_BIT_MASK 0x10
25. #endif
26. #define KBD_COLUMN_COUNT 4
27. #elif defined(KBD_PHONE_KEYPAD)
28. #if (USE_KBD_FIRST_COLUMN_BIT == 0)
29.   #define KBD_COLUMN_TRIS_MASK 0xF8
30.   #define KBD_COLUMN_DATA_MASK 0x07
31.   #define KBD_FIRST_BIT_MASK 0x01
32. #elif (USE_KBD_FIRST_COLUMN_BIT == 1)
33.   #define KBD_COLUMN_TRIS_MASK 0xF1
34.   #define KBD_COLUMN_DATA_MASK 0x0E
35.   #define KBD_FIRST_BIT_MASK 0x02
36. #elif (USE_KBD_FIRST_COLUMN_BIT == 4)
37.   #define KBD_COLUMN_TRIS_MASK 0x8F
38.   #define KBD_COLUMN_DATA_MASK 0x70
39.   #define KBD_FIRST_BIT_MASK 0x10
40. #elif (USE_KBD_FIRST_COLUMN_BIT == 5)
41.   #define KBD_COLUMN_TRIS_MASK 0x1F
42.   #define KBD_COLUMN_DATA_MASK 0xE0
43.   #define KBD_FIRST_BIT_MASK 0x20
44. #endif
45. #define KBD_COLUMN_COUNT 3
46. #endif
47.       KBD_COLUMN_TRIS &= KBD_COLUMN_TRIS_MASK;
48. #define KBD_ROW_COUNT 4
49.   }
50.  
51.   /*
52.    * Devuelve 1 si hay alguna tecla presionada, o 0 si no hay tecla presionada
53.    */
54.   bit KBDIsKeyHit(void)
55.   {
56.       uint8_t key;
57.  
58. #if defined(USE_KBD_PULLDOWN_RESISTOR)
59.       key = KBD_ROW_PORT;
60. #elif defined(USE_KBD_PULLUP_RESISTOR)
61.       key = ~KBD_ROW_PORT;
62. #endif
63. #if defined(USE_KBD_ROW_LOWER_NIBBLE)
64.       key = key & 0x0F;
65. #elif defined(USE_KBD_ROW_UPPER_NIBBLE)
66.       key = key >> 4;
67. #endif
68.       if (key != 0) return 1;
69.       else
70.           return 0;
71.   }
72.  
73.   /*
74.    * Activa todas las salidas
75.    */
76.   void KBDSetColumn(void)
77.   {
78. #if defined(USE_KBD_PULLDOWN_RESISTOR)
79.       KBD_COLUMN_PORT |= KBD_COLUMN_DATA_MASK;
80. #elif defined(USE_KBD_PULLUP_RESISTOR)
81.       KBD_COLUMN_PORT &= ~KBD_COLUMN_DATA_MASK;
82. #endif
83.   }
84.  
85. #if defined(KBD_PHONE_KEYPAD)
86.   const uint8_t asciiCode[KBD_ROW_COUNT][KBD_COLUMN_COUNT] = {'1','2','3',
87.                                                               '4','5','6',
88.                                                               '7','8','9',
89.                                                               '*','0','#'};
90. #elif defined(KBD_HEXA_KEYPAD)
91.   const uint8_t asciiCode[KBD_ROW_COUNT][KBD_COLUMN_COUNT] = {'0','1','2','3',
92.                                                               '4','5','6','7',
93.                                                               '8','9','A','B',
94.                                                               'C','D','E','F'};
95. #endif
96.  
97.   /*
98.    * Delvuelve el codigo ascii de la tecla presionada
99.    */
100.   uint8_t KBDGetKey(void)
101.   {
102.       uint8_t columnNumber;
103.       uint8_t rowNumber;
104.       uint8_t key;
105.  
106.       columnNumber = 0;
107.       do
108.       {
109.           KBD_COLUMN_TRIS |= ~KBD_COLUMN_TRIS_MASK;
110.           KBD_COLUMN_TRIS &= ~(KBD_FIRST_BIT_MASK << columnNumber);
111. #if defined(USE_KBD_PULLDOWN_RESISTOR)
112.           KBD_COLUMN_PORT |= (KBD_FIRST_BIT_MASK << columnNumber);
113. #elif defined(USE_KBD_PULLUP_RESISTOR)
114.           KBD_COLUMN_PORT &= ~(KBD_FIRST_BIT_MASK << columnNumber);
115. #endif
116.           columnNumber++;
117.           key = KBD_ROW_PORT;
118. #if defined(USE_KBD_ROW_UPPER_NIBBLE)
119.           key = key >> 4;
120. #endif
121. #if defined(USE_KBD_PULLUP_RESISTOR)
122.           key = ~key;
123. #endif
124.           key &= 0x0F;
125.       }
126.       while ((key == 0) && (columnNumber < KBD_COLUMN_COUNT));
127.       switch (key)
128.       {
129.           case 1:
130.           {
131.               rowNumber = 0;
132.               break;
133.           }
134.           case 2:
135.           {
136.               rowNumber = 1;
137.               break;
138.           }
139.           case 4:
140.           {
141.               rowNumber = 2;
142.               break;
143.           }
144.           case 8:
145.           {
146.               rowNumber = 3;
147.               break;
148.           }
149.       }
150.       KBD_COLUMN_TRIS &= KBD_COLUMN_TRIS_MASK;
151.       KBDSetColumn();
152.       if (key != 0) return asciiCode[rowNumber][columnNumber - 1];
153.       else
154.           return 0;
155.   }
156. #endif

[AngelGris]

  Y aquí el ejemplo de uso de la librería del teclado... Utilizo el puertoC para mostrar el valor.

Código: C

1. #include <xc.h>
2.  
3. #pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator)
4. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
5. #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
6. #pragma config BOREN = OFF      // Brown-out Reset Enable bit (BOR disabled)
7. #pragma config LVP = OFF        // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
8. #pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
9. #pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
10. #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
11.  
12. #include <stdint.h>
13. #include "xckbd.h"
14.  
15. #define _XTAL_FREQ 20000000
16.  
17. void main(void)
18. {
19.     uint8_t lastKeyHit;
20.     uint8_t tecla;
21.  
22.     lastKeyHit = 0;
23.     CMCON = 7;
24.     ADCON1 = 7;
25.     PORTC = 0;
26.     TRISC = 0;
27.     KBDInit();
28.     KBDSetColumn();
29.     while(1)
30.     {
31.         if ((lastKeyHit == 1) && (KBDIsKeyHit() == 0))
32.             lastKeyHit = 0;
33.         if ((lastKeyHit == 0) && (KBDIsKeyHit() == 1))
34.         {
35.             __delay_ms(10);
36.             if (KBDIsKeyHit() == 1)
37.             {
38.                 lastKeyHit = 1;
39.                 tecla = KBDGetKey();
40.                 PORTC = tecla;
41.             }
42.         }
43.     }
44. }

[Micom]

Me estoy iniciando con el CX8 y quería ver las ejecuciones paso a paso de algunos programitas sencillos que copie de este gran curso y no encuentro los archivos .cof, nose si el cx8 los genera o no?? o como se hace para generarlos.

[AngelGris]

Me estoy iniciando con el CX8 y quería ver las ejecuciones paso a paso de algunos programitas sencillos que copie de este gran curso y no encuentro los archivos .cof, nose si el cx8 los genera o no?? o como se hace para generarlos.

  Los archivos .cof se generan al compilar los programas