Mini curso "Programación en XC8"

[NIN]

Empecemos primero por la forma del programa, Voy a escribir masomenos como estan formados todos los main.c:

Código: C

1. // Aca los #include
2.  
3. // Aca los FUSES
4.  
5. // Prototipos de funciones y variables
6.  
7. void main(void)
8. {
9.         // Aca la configuracion de cada modulo que se vaya a usar
10.  
11.         while(1)                // Loop infinito, el unico loop infinito que hay en todo el programa.
12.         {
13.                 //Aca el programa en cuestion
14.         }
15. }
16.  
17. // Otras funciones si es que es el caso

Ahora vamos adentro de la funcion main y veamos como quedaria el codigo:

El CCP del PIC16F88 utiliza el timer 2, si observas al final de la parte de PWM ahi estan TODOS los regsotrs y bits que estan involucrados con el PWM, algunos registros solo tiene 1 bit como es PIE1 por ejemplo que corresponde al PWM. Voy a usar valores obtenidos de una calculadora online. Igual lo explico en el comentario, si tenes alguna duda podes ver el diagrama del PWM, observa que solo basta configurar el PWM y darle arranque al TMR2, luego de ahi no tenes que hacer mas nada.

Código: C

1. void main(void)
2. {
3.  
4.         //Aca configuracion de modulos
5.  
6.         // Puertos
7.  
8.         TRISB = 0;              // Todas salidas por ahora nomas, la salida PWM puede estar en RB0 o RB3 segun el fuse que se elija.
9.         PORTB = 0;              // Apagamos todos
10.  
11.  
12.         // CCP
13.  
14.         CCP1CON = 0x1C;         // En PWM, y los ultimos 2 bits ( de los 10 del duty ) es 01
15.         PR2 = 0x7C;             // Periodo va estar dado por PR2, y como este el timer2 configurado, 0x7C = 124, pero se crea virtualmente 2 bits mas, resultado periodo igual a 496
16.         T2CON = 0x07;           // T2CON, postscaler = 1, prescaler = 16, TMR2 ON. Periodo : (PR2+1)*4*Tosc*(Prescaler) = (124+1)*4*Tosc*16 = 8000 * 0.250us = 2ms
17.         CCPR1L = 0x3E;          // Valor real de duty que con los 2 bits del CCP1CON es 0xF9 = 249, virtualmente el PWM hace llegar al timer hasta 496, un duty de 50% 496 * 0.5 = 248
18.  
19.         while(1)
20.         {
21.         }
22.  
23. }

2 cosas mas, usa FOSC = XT para 4Mhz o menos y HS para cuando tenes mas de 4Mhz, y... no hace falta que agregues tantos includes, con el de xc.h se agrega el del pic16f88 por si solo. es decir solo necesitas este include:

Código: C

1. #include <xc.h>

Aunque a veces da problemas igual..

Y el MPLAB X tiene una forma facil de generar codigo para crearte los fuses

Muchisimas gracias KILLER. Exactamente este era el tipo de respuesta que queria. Que no modificara tanto mi programa y saber cuales eran mis errores.

Quisiera que me ayudes en mi camino, porque te puedo asegurar que voy a tener muchisimas dudas con este aprendizaje

Sinceramente
NIN.

[NIN]

Buenas noches. Esta pregunta es muy basica pero en serio no me sale la compilacion. Vamos por un programa simple para que se entienda.

Tengo este programa que prende el led mediante un funcion llamada " prender" :

Código: [Seleccionar]

#include <xc.h>

#define _XTAL_FREQ 10000

#pragma config WDTE = OFF
#pragma config FOSC = XT
#pragma config CCPMX = RB0

void prender ()
{
    PORTBbits.RB1 = 1;
   
}
void main()
{
    TRISB = 0b00000001;
    PORTB = 0b00000001;
   
   
        while (PORTBbits.RB0 == 1)
        {
            prender();
        }
   
}

Funciona perfectamente.

Ahora supongamos que quiero realizar mi propia libreria externa llamada "prender" hago los siguiente:

Creo mi libreria llamada "prender.h", y esta tiene una funcion llamada "luz" (para que prenda el led)

prender2.png
(68.99 kB, 960x720 - visto 1145 veces)

A su vez llamo a esta libreria desde el programa principal con el "#include<prender.h>":

prender1.png
(83.94 kB, 960x720 - visto 1374 veces)

pero me sale error de compilacion. Que podria hacer para eliminar ese error.Muchas gracias.

Sinceramente NIN.

[KILLERJC]

main.c

Código: C

1. #include <xc.h>
2. #include "prender.h"
3.  
4. #pragma config WDTE = OFF
5. #pragma config FOSC = XT
6. #pragma config CCPMX = RB0
7.  
8. void main()
9. {
10.     TRISB = 0b00000001;
11.     PORTB = 0b00000001;
12.    
13.    
14.         while (PORTBbits.RB0 == 1)
15.         {
16.             Luz();
17.         }
18. }

prender.h

Código: C

1. #ifndef PRENDER_H
2. #define PRENDER_H
3.  
4. void luz(void);
5.  
6. #endif // PRENDER_H

prender.c

Código: C

1. #include <xc.h>
2. #include "prender.h"
3.  
4. void Luz(void)
5. {
6.       PORTBbits.RB1 = 1;
7. }

Primero que nada no poner codigo en los .h, aunque se puede hacer.
Pusiste la parte del .h dentro de la seccion para C++, cosa que no se usa en XC8, podras observar que yo no lo puse en mi .h. Si sacaras tu codigo afuera funcionaria, pero violaria lo de antes.
Otra cosa mas, es que inclui en el prender.c a xc.h nuevamente, para poder usar el "PORTBbits"

[NIN]

main.c

Código: C

1. #include <xc.h>
2. #include "prender.h"
3.  
4. #pragma config WDTE = OFF
5. #pragma config FOSC = XT
6. #pragma config CCPMX = RB0
7.  
8. void main()
9. {
10.     TRISB = 0b00000001;
11.     PORTB = 0b00000001;
12.    
13.    
14.         while (PORTBbits.RB0 == 1)
15.         {
16.             Luz();
17.         }
18. }

prender.h

Código: C

1. #ifndef PRENDER_H
2. #define PRENDER_H
3.  
4. void luz(void);
5.  
6. #endif // PRENDER_H

prender.c

Código: C

1. #include <xc.h>
2. #include "prender.h"
3.  
4. void Luz(void)
5. {
6.       PORTBbits.RB1 = 1;
7. }

Primero que nada no poner codigo en los .h, aunque se puede hacer.
Pusiste la parte del .h dentro de la seccion para C++, cosa que no se usa en XC8, podras observar que yo no lo puse en mi .h. Si sacaras tu codigo afuera funcionaria, pero violaria lo de antes.
Otra cosa mas, es que inclui en el prender.c a xc.h nuevamente, para poder usar el "PORTBbits"

Como siempre Killer muchisimas gracias. Las cosas que me cuesta demasiado hacer tu me ayudas un monton. Habia buscado muchisimo como hacer tengo varios dias intentandolo y tu me ayudas demasiado.

Sinceramente NIN

[Rseliman]

Hola Amigos , hace un tiempo que no escribo nada por aca , estuve haciendo unas pruebas con un HC_SR04 y un 5110 en xc8 y como no hay nada sobre estos dos temas en la red , queria compartirlo con UDS !!! espero les sirva use un pic 16f648 ...

Saludos a todos

Código: [Seleccionar]

user.h

void LCDWrite(unsigned char data_or_command, unsigned char data);
void gotoXY(int x, int y);
void LCDBitmap(char my_array[]);
void LCDCharacter(char character);
void LCDString(char *characters);
void LCDClear(void);
void LCDInit(void) ;
void LCDNumero(long num );
const unsigned char ramiro[];

void InitApp(void);         /* I/O and Peripheral Initialization */


Código: [Seleccionar]

user.c

/*
 * File:   user.c
 * Author: Ramiro
 *
 * Created on 20 de junio de 2016, 9:44
 */

/******************************************************************************/
/* Files to Include                                                           */
/******************************************************************************/

#if defined(__XC)
    #include <xc.h>         /* XC8 General Include File */
#elif defined(HI_TECH_C)
    #include <htc.h>        /* HiTech General Include File */
#endif

#include <stdint.h>         /* For uint8_t definition */
#include <stdbool.h>
#include <pic16f628a.h>        /* For true/false definition */

#include "user.h"

/******************************************************************************/
/* User Functions                                                             */
/******************************************************************************/

#define LCD_CLK PORTBbits.RB5
#define LCD_DIN PORTBbits.RB4
#define LCD_DC PORTBbits.RB3
#define LCD_CE PORTBbits.RB2
#define LCD_RST PORTBbits.RB7


//The DC pin tells the LCD if we are sending a command or data
#define LCD_COMMAND 0
#define LCD_DATA  1

//You may find a different size screen, but this one is 84 by 48 pixels
#define LCD_X     84
#define LCD_Y     48

//------------------------------------------------------------------------------
// File generated by LCD Assistant
// http://en.radzio.dxp.pl/bitmap_converter/
//------------------------------------------------------------------------------

const unsigned char ramiro[] = {
0x80, 0xE0, 0xF0, 0xF8, 0xF8, 0xFC, 0x7C, 0x7E, 0x3E, 0x3E, 0x3E, 0x1F, 0x1F, 0x1F, 0x1F, 0x9F,
0x9F, 0x9F, 0x1F, 0x1F, 0x9F, 0x9F, 0x9F, 0x1F, 0x1F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x1F,
0x1F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x1F, 0x1F, 0x1F, 0x9F, 0x9F, 0x1F, 0x1F, 0x9F, 0x9F,
0x9F, 0x9F, 0x9F, 0x9F, 0x1F, 0x1F, 0x1F, 0x1F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x1F, 0x1F, 0x1F,
0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x1F, 0x1F, 0x1F, 0x3E, 0x3E, 0x3E, 0x7E, 0x7C, 0xFC, 0xF8,
0xF8, 0xF0, 0xE0, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x7F, 0x7F, 0x0F, 0x7C, 0x7C, 0x0F, 0x7F, 0x7F, 0x00, 0x00, 0x7F, 0x7F, 0x6D,
0x6D, 0x6D, 0x6D, 0x00, 0x00, 0x7F, 0x7F, 0x61, 0x61, 0x61, 0x7F, 0x3F, 0x00, 0x00, 0x7F, 0x7F,
0x00, 0x00, 0x7F, 0x7F, 0x61, 0x61, 0x61, 0x7F, 0x3F, 0x00, 0x00, 0x3F, 0x7F, 0x61, 0x61, 0x61,
0x7F, 0x3F, 0x00, 0x00, 0x7F, 0x7F, 0x0D, 0x0D, 0x3D, 0x7F, 0x67, 0x40, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, 0xE0, 0xF0, 0xF0, 0xF8, 0xFC, 0xFC, 0xFE, 0xFE, 0xFE, 0xFC, 0xF8, 0xF8, 0xF0, 0xE0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xF8, 0x18, 0x18, 0x18,
0xF8, 0xF0, 0x00, 0x00, 0xF8, 0xF8, 0xD8, 0xD8, 0xD8, 0xD8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xF0, 0xF0, 0xF8, 0xFC, 0xFC, 0xFE, 0xFE, 0xFE, 0xFC, 0xF8,
0xF8, 0xF0, 0xE0, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x81, 0x87, 0x8F, 0x8F, 0x8F, 0x0F, 0x0F, 0x0F, 0x8F,
0x8F, 0x07, 0x01, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x87,
0x87, 0x86, 0x06, 0x06, 0x07, 0x83, 0x80, 0x80, 0x07, 0x07, 0x06, 0x06, 0x86, 0x86, 0x00, 0x00,
0x00, 0x80, 0x80, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x81, 0x07, 0x0F, 0x0F, 0x8F, 0x8F,
0x0F, 0x0F, 0x0F, 0x0F, 0x87, 0x81, 0x80, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x61, 0x61, 0x61, 0x7F,
0x3F, 0x00, 0x00, 0x7F, 0x7F, 0x00, 0x00, 0x67, 0x67, 0x6D, 0x6D, 0x7D, 0x39, 0x10, 0x01, 0x01,
0x01, 0x7F, 0x7F, 0x01, 0x01, 0x01, 0x40, 0x78, 0x7E, 0x37, 0x33, 0x3F, 0x7E, 0x78, 0x40, 0x00,
0x7F, 0x7F, 0x07, 0x1E, 0x38, 0x7F, 0x7F, 0x00, 0x00, 0x3F, 0x7F, 0x61, 0x61, 0x61, 0x73, 0x33,
0x00, 0x00, 0x7F, 0x7F, 0x00, 0x40, 0x78, 0x7E, 0x37, 0x33, 0x3F, 0x7E, 0x78, 0x40, 0x00, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x3F, 0x3E, 0x7E, 0x7C, 0x7C, 0x7C,
0x7C, 0x7C, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8,
0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8,
0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8,
0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0x7C, 0x7C, 0x7C, 0x7C, 0x7C, 0x7E,
0x3E, 0x3F, 0x3F, 0x1F, 0x0F, 0x0F, 0x07, 0x01,
};




/* <Initialize variables in user.h and insert code for user algorithms.> */
const unsigned char ASCII[][5] = {
{0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 ?
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 ?
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d ?
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c "\"
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ~
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f DEL
};

void setup(void) {
  LCDInit(); //Init the LCD
}

void loop(void) {
  LCDClear();
 // LCDBitmap(SFEFlame);
 // delay(1000);

 // LCDClear();
 // LCDBitmap(SFEFlameBubble);
 /// delay(1000);

//  LCDClear();
 // LCDBitmap(awesome);
 // delay(1000);

  //LCDClear();
  LCDString("Hello World!");
 // delay(1000);
}

void gotoXY(int x, int y) {
  LCDWrite(0, 0x80 | x);  // Column.
  LCDWrite(0, 0x40 | y);  // Row.  ?
}

//This takes a large array of bits and sends them to the LCD
void LCDBitmap(char my_array[]){
  for (int index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
    LCDWrite(LCD_DATA, my_array[index]);
}

//This function takes in a character, looks it up in the font table/array
//And writes it to the screen
//Each character is 8 bits tall and 5 bits wide. We pad one blank column of
//pixels on each side of the character for readability.
void LCDCharacter(char character) {
  LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding

  for (int index = 0 ; index < 5 ; index++)
    LCDWrite(LCD_DATA, ASCII[character - 0x20][index]);
    //0x20 is the ASCII character for Space (' '). The font table starts with this character

  LCDWrite(LCD_DATA, 0x00); //Blank vertical line padding
}

//Given a string of characters, one by one is passed to the LCD
void LCDString(char *characters) {
  while (*characters)
  {
    LCDCharacter(*characters);
    *characters++;
  }
}

//Clears the LCD by writing zeros to the entire screen
void LCDClear(void) {
  for (int index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
    LCDWrite(LCD_DATA, 0x00);

  gotoXY(0, 0); //After we clear the display, return to the home position
}

//This sends the magical commands to the PCD8544
void LCDInit(void) {

  //Configure control pins
    TRISBbits.TRISB3=0;
    TRISBbits.TRISB4=0;
    TRISBbits.TRISB5=0;
    TRISBbits.TRISB6=0;
    TRISBbits.TRISB7=0;

    LCD_DIN=0;
    LCD_CLK=0;
    LCD_DC=0;

//  pinMode(PIN_SCE, OUTPUT);
//  pinMode(PIN_RESET, OUTPUT);
//  pinMode(PIN_DC, OUTPUT);
//  pinMode(PIN_SDIN, OUTPUT);
//  pinMode(PIN_SCLK, OUTPUT);

  //Reset the LCD to a known state
 // digitalWrite(PIN_RESET, LOW);
  LCD_RST=0;
  //  digitalWrite(PIN_RESET, HIGH);
  LCD_RST=1;

  LCDWrite(LCD_COMMAND, 0x21); //Tell LCD that extended commands follow
  LCDWrite(LCD_COMMAND, 0xBB); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
  LCDWrite(LCD_COMMAND, 0x04); //Set Temp coefficent
  LCDWrite(LCD_COMMAND, 0x14); //LCD bias mode 1:48: Try 0x13 or 0x14

  LCDWrite(LCD_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
  LCDWrite(LCD_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse
}

//There are two memory banks in the LCD, data/RAM and commands. This
//function sets the DC pin high or low depending, and then sends
//the data byte
void LCDWrite(unsigned char data_or_command, unsigned char data) {
  unsigned char i,d;

  d=data;
  if(data_or_command==0)LCD_DC=0;
  else LCD_DC=1;
  //data_or_command; //Tell the LCD that we are writing either to data or a command

  //Send the data
  LCD_CE=0;
//  digitalWrite(PIN_SCE, LOW);

  for(i=0;i<8;i++)
  {
  LCD_DIN=0;
  if(d&0x80)LCD_DIN=1;
  LCD_CLK=1;
  d<<=1;
  LCD_CLK=0;
  }
//  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  LCD_CE=1;
//  digitalWrite(PIN_SCE, HIGH);
}

void InitApp(void)
{
    /* TODO Initialize User Ports/Peripherals/Project here */

    /* Setup analog functionality and port direction */
   
    /* Initialize peripherals */
    // OPTION_REG=0x80;
    /* Enable interrupts */
    TMR0IE=1;
    GIE=1;

}



Código: [Seleccionar]


system.h

/******************************************************************************/
/* System Level #define Macros                                                */
/******************************************************************************/

/* TODO Define system operating frequency */

/* Microcontroller MIPs (FCY) */
#define SYS_FREQ        400000L
#define FCY             SYS_FREQ/4

extern unsigned char spk_bit;
extern unsigned char led_bit;
extern unsigned char spk_enable,spk_enable2;
extern unsigned int led_counter;

/******************************************************************************/
/* System Function Prototypes                                                 */
/******************************************************************************/

/* Custom oscillator configuration funtions, reset source evaluation
functions, and other non-peripheral microcontroller initialization functions
go here. */

void ConfigureOscillator(void); /* Handles clock switching/osc initialization */



Código: [Seleccionar]

system.c

/*
 * File:   System.c
 * Author: Ramiro
 *
 * Created on 20 de junio de 2016, 9:42
 */

/******************************************************************************/
/*Files to Include                                                            */
/******************************************************************************/

#if defined(__XC)
    #include <xc.h>         /* XC8 General Include File */
#elif defined(HI_TECH_C)
    #include <htc.h>        /* HiTech General Include File */
#endif

#include <stdint.h>        /* For uint8_t definition */
#include <stdbool.h>       /* For true/false definition */

#include "system.h"

/* Refer to the device datasheet for information about available
oscillator configurations. */
void ConfigureOscillator(void)
{
    /* TODO Add clock switching code if appropriate.  */

    /* Typical actions in this function are to tweak the oscillator tuning
    register, select new clock sources, and to wait until new clock sources
    are stable before resuming execution of the main project. */
}




Código: [Seleccionar]

main.c


#define _XTAL_FREQ 4000000

#include <xc.h>
#include <pic16f628a.h>
#include <stdio.h>
#include <stdlib.h>
#include "confbits.h"
#include <stdint.h>        /* For uint8_t definition */
#include <stdbool.h>       /* For true/false definition */
#include "user.h"
#include "system.h" /* System funct/params, like osc/peripheral config */
                      /* User funct/params, such as InitApp */
#define triger PORTBbits.RB0
#define echo PORTBbits.RB1

/******************************************************************************/
/* User Global Variable Declaration                                           */
/******************************************************************************/

unsigned char led_bit,spk_bit,spk_enable,spk_enable2;
unsigned int led_counter,a;
char salida[20] ;
/* i.e. uint8_t <variable_name>; */

/******************************************************************************/
/* Main Program                                                               */
/******************************************************************************/
/************************/


void main(void)

{
      // **********************inicializo el micro
      // ******************** inicializacion cpu *************************** 
     
      PCONbits.OSCF;// reloj en 4 mhz
      CMCON = 0X07 ; //apaga los comparadores y habilita los pines de I/O
      TRISA = 0x00;
      PORTA = 0X00;
      TRISB = 0x00;
      TRISBbits.TRISB1 = 1;
     
   

    /* Configure the oscillator for the device */
    ConfigureOscillator();

    /* Initialize I/O and Peripherals for application */
    InitApp();
         
    led_counter=0;
    spk_bit=0;
    led_bit=0;
      LCDInit();
      LCDClear();
      gotoXY(0,0);
      LCDBitmap(ramiro);
     
      __delay_ms(5000);
      LCDClear();
             
    while(1)
    {
   
        T1CONbits.TMR1CS = 0;
       
        TMR1H = 0;                  //Sets the Initial Value of Timer
        TMR1L = 0;                  //Sets the Initial Value of Timer

       
        triger = 1; // disparo el triger del distanciometro
        __delay_us(10); // espero 10 us
       
        triger = 0; // apago el triger
       
       
           
       
       
       
       while(!echo);           //Waiting for Echo
       T1CONbits.TMR1ON = 1;              //Timer Starts
       while(echo);            //Waiting for Echo goes LOW
        T1CONbits.TMR1ON = 0;            //Timer Stops

       
               a = (TMR1L | (TMR1H<<8));   //Reads Timer Value
               a = a/58.82;                //Converts Time to Distance
                             //Distance Calibration
               itoa(salida,a,10);
               if(a>=2 && a<=400)          //Check whether the result is valid or not
               {
                LCDClear();
                gotoXY(15,2);

                LCDString("DISTANCIA");
                gotoXY(25,4);
                LCDString(salida);
                LCDString(" cm");
               }
               else
                {
                LCDClear;
                gotoXY(0,5);
                LCDString("out of range");
                }
                 __delay_ms(300);
                   
     //   if(spk_bit==1)
       //  {
         //   if((spk_enable==1)&&(spk_enable2==1))
           //  TRISBbits.TRISB6=1;
        // }  else TRISBbits.TRISB6=0;
             
    }
}


[NIN]

Buenas noches de nuevo. Realmente he aprendido mucho gracias a sus valiosisimas ayudas. (Sobre todo gracias a KILLER). Sin su ayuda creo que me hubiera desanimado y hubiera dejado esto botado.

Al grano.

Resulta que tengo esta configuracion:

3 led.png
(106.53 kB, 960x720 - visto 1052 veces)

Simplemente es :

Si aprieto RA0 se prende RB0
Si aprieto RA1 se prende RB1
Si aprieto RA2 se prende RA2.

Ya realice el codigo con "if...else" anidados. Este es el codigo que realice :

Código: [Seleccionar]

#include <xc.h>

#pragma config WDTE = OFF
#pragma config FOSC = XT
#pragma config CCPMX = RB0


void main()
{
    TRISA = 0b00000111;
    PORTA = 0b00000111;
    TRISB = 0b00000000;
    PORTB = 0b00000000;
    ANSEL = 0b00000000;   
    while(1)
    {
             
        if (PORTAbits.RA0==1)
        {
            PORTBbits.RB0=1;
        }
        else if (PORTAbits.RA1==1)
        {
            PORTBbits.RB1=1;
        }
        else if (PORTAbits.RA2==1)
        {
            PORTBbits.RB2=1;
        }
        else
        {
            PORTB = 0b00000000;
        }
    }
}
Me salio a la perfeccion. Pero ahora lo quiero hacer con las sentencia "switch...case". aqui empiezan mis problemas:

Código: [Seleccionar]

#include <xc.h>

#pragma config CCPMX = RB0
#pragma config WDTE = OFF

 void main (void)
{
     TRISA = 0b00000111;
    PORTA = 0b00000111;
    TRISB = 0b00000000;
    PORTB = 0b00000000;
    ANSEL = 0b00000000;
     
     unsigned char input ;
     
     while(1)
     {
         switch (input)
         {
             case :
             
         }
         
     }
         
   
}



El principal problema al que le busco  solucion es como puedo almacenar el estado de un puerto (boton pulsado o boton sin pulsar) en una variable en el xc8. (en este caso yo le puse "input"). En GCC es con "scanf()", pero como se puede hacer aqui ?

Saque esto del manual. Sin embargo el manual no dice nada sobre almacenamiento de variables para hacer match con el "case"

Código: [Seleccionar]

int a;
switch(input) {
case a: /* oops!
cannot use variable as part of a case label */
input++;
}
Bueno espero su ayuda.

Sinceramente,
NIN.

[KILLERJC]

Código: C

1. void main (void)
2. {
3.         unsigned char input ;
4.  
5.         TRISA = 0b00000111;
6.         PORTA = 0b00000111;
7.         TRISB = 0b00000000;
8.         PORTB = 0b00000000;
9.         ANSEL = 0b00000000;
10.      
11.    
12.         while(1)
13.         {
14.                 input = PORTA & 0b111;          // Me aseguro que solo queden los valores de RA0, RA1 y RA2
15.                 switch (input)
16.                 {
17.                 case 0b001:
18.                         //RA0
19.                         PORTBbits.RB0=1;
20.                         break:
21.                 case 0b010:
22.                         PORTBbits.RB1=1;
23.                         //RA1
24.                         break:
25.                 case 0b100:
26.                         //RA2
27.                         PORTBbits.RB2=1;
28.                         break:
29.                 default:
30.                         //Cualquier otra combinacion ejemplo RA2 y RA1 juntos, etc.
31.                         PORTB = 0;
32.                         break;
33.          }
34.          
35.      }
36. }

EL switch case solo admite valores numericos, es decir 0x12 , 30 , 0b1213 , 'a' , o algun enum

Vas a observar que si presionas 2 juntos sea cual sea va a poner a 0 el puerto completo, por que al no estar el case con el numero que debe, entra en "default".

[AcoranTf]

Hola gente, necesito las librerias perifericas de XC8. Las encontre en un archivo instalador de windows, pero yo utilizo Linux y no me deja extraerlas de ahi.
¿Alguien las tiene o sabe de donde descargarlas en un formato compatible Linux?.

Saludos.

[KILLERJC]

Realmente en 8 bits nunca me maneje con una libreria, creo ni siquiera dan el codigo, distinto a XC16 en adelante que si te dan el codigo de los perifericos y ademas deberias tener un PDF.

Por que la mayoria de los modulos son 2/3 registros como maximo.

PD: Yo uso el MPLAB en Linux

[AngelGris]

Hola gente, necesito las librerias perifericas de XC8. Las encontre en un archivo instalador de windows, pero yo utilizo Minux y no me deja extraerlas de ahi.
¿Alguien las tiene o sabe de donde descargarlas en un formato compatible Linux?.

Saludos.

  Hola AcoranTf, ¿A qué te refieres, a las de ADC, por ejemplo?
De ser así, las hay. Pero creo que sólo para las familias 18xxxxx
En Debian Jessie las tengo en "/opt/microchip/xc8/v1.33/sources/pic18/plib"

[AcoranTf]

Realmente en 8 bits nunca me maneje con una libreria, creo ni siquiera dan el codigo, distinto a XC16 en adelante que si te dan el codigo de los perifericos y ademas deberias tener un PDF.

Por que la mayoria de los modulos son 2/3 registros como maximo.

PD: Yo uso el MPLAB en Linux

Hola KILLERJC, principalmente las quiero para ver el codigo y aprender a hacer a "mano" algunas de sus funciones. El PDF al que te refieres no esta en mi instalacion, ya habia visto buscando por google que lo citan en algunos sitios, pero en mi PC no esta ese PDF.
Gracias de todos modos.

Hola gente, necesito las librerias perifericas de XC8. Las encontre en un archivo instalador de windows, pero yo utilizo Minux y no me deja extraerlas de ahi.
¿Alguien las tiene o sabe de donde descargarlas en un formato compatible Linux?.

Saludos.

  Hola AcoranTf, ¿A qué te refieres, a las de ADC, por ejemplo?
De ser así, las hay. Pero creo que sólo para las familias 18xxxxx
En Debian Jessie las tengo en "/opt/microchip/xc8/v1.33/sources/pic18/plib"

Hola Angel Gris, si me referia a esas y otras mas, son un monton de ellas para manejar los perifericos, aunque como le contestaba a KILLERJC, las quiero sobretodo para tener info de como se hacen algunas cosas. Y si se que solo valen para los PIC18. En esa carpeta ya mire y no hay nada, no se si sera porque la instalacion que yo hice es la que se descarga gratuitamente de Microchip y parece ser, segun lei que no incluye esas librerias. En la carpeta que citas yo solo tengo 21 archivos y dos carpetas, que no incluyen esas lñibrerias.
Gracias igualmente por tu respuesta.

Saludos.

[AcoranTf]

Lo borre por estar repetido.

[KILLERJC]

Asi como dice AngelGris, es justamente para PIC18, pero no se si estan todas las funciones a simple vista

.../Microchip/xc8/v1.xx/docs/MPLAB_XC8_Peripheral_Libraries.pdf
.../Microchip/xc8/v1.xx/include/plib/...
.../Microchip/xc8/v1.xx/sources/pic18/plib/...

De todas formas creo mas facil usar el datasheet del micro, y al final de cada modulo te aparece que registros son los necesarios. Incluso te sule poner un paso a paso sobre como configurar el modulo.
En las librerias vas a ver muchas mas cosas de las que necesitas, si es que realmente queres aprenderlo.

[AcoranTf]

Asi como dice AngelGris, es justamente para PIC18, pero no se si estan todas las funciones a simple vista

.../Microchip/xc8/v1.xx/docs/MPLAB_XC8_Peripheral_Libraries.pdf
.../Microchip/xc8/v1.xx/include/plib/...
.../Microchip/xc8/v1.xx/sources/pic18/plib/...

De todas formas creo mas facil usar el datasheet del micro, y al final de cada modulo te aparece que registros son los necesarios. Incluso te sule poner un paso a paso sobre como configurar el modulo.
En las librerias vas a ver muchas mas cosas de las que necesitas, si es que realmente queres aprenderlo.

Entiendo lo que comentas, lo que ocurre es que pense que sria mas sencillo verlo en las librerias y mas si contienen comentarios, pero tienes razon, todo es ponerse tranquilamente con la documentacion del PIC.

Saludos.

[AngelGris]

  Yo también instalé la versión gratis. Ahora no estoy en casa, pero recuerdo que hay una carpeta por periférico. Me vienen a la mente, ADC, I2C, SPI, UART, CCPM, I2C por software.... a la noche me fijo en case y te paso el listado de las carpetas.