Mini curso "Programación en XC8"

[carferper]

Saludos, puedes crear funciones como en el ejemplo siguiente:

Código: [Seleccionar]

#include <xc.h>                      /* definiciones 12F683 */

#define _XTAL_FREQ 4000000
#define __delay_ms(x) _delay((unsigned long)((x)*(_XTAL_FREQ/4000.0)))

#pragma config FOSC = INTOSCIO, WDTE = OFF, PWRTE = OFF, MCLRE = OFF
#pragma config CP = OFF, CPD = OFF, BOREN = OFF, IESO = OFF, FCMEN = OFF

void toggle_bit(int pin){
    GPIO ^= (1<<pin);               /* cambia estado de pin en GPIO */
}

void main (void){
    CMCON0     |= 0b00000111;       /* desactiva comparadores */
    ANSEL      &= 0b11110000;       /* puerto como E/S digitales */
    GPIO        = 0b000000;         /* inicia con LEDs apagados */
    TRISIO      = 0b111000;         /* GP1, GP2 y GP3 como salidas */
    OPTION_REG &= 0b01111111;       /* habilita "pull-ups" internos */

    int pin = 0;

    while (1){
        for (pin = 0; pin < 3; pin++){
            toggle_bit(pin);            
            __delay_ms(200);
        }
    }
}
asi solo debes pasar el bit que quieres modificar mediante la variable pin.

[jukinch]

Jeremylf:
         sumando a lo que han propuesto carferper y rseliman también podés tratar el puerto con una máscara (funciona como un colador dejando pasar sólo el bit que le permitimos) con operadores a nivel de bits para acceder a los bits individuales del registro en cuestión con una variable a modo de índice.
         

Código: [Seleccionar]

int n=0;
while (1)
{
   
    for(n=0;n<8;n++)
    {
        LATD =(LATD |= 1<<n); // pone en 1 el bit n del puerto D
        myMsDelay(100);
        LATD &= (~(1<<n));    // pone en 0 el bit n del puerto D
    }
    for(n=6;n>=1;n--)
    {
        LATD=(LATD |= 1<<n); // pone en 1 el bit n del puerto D
        myMsDelay(100);
        LATD &= (~(1<<n));   // pone en 0 el bit n del puerto D
    }
}
Con estas líneas de código podemos hacerle honor al más preciado programa del auto fantástico!

Adjunto proyecto completo y simulación en proteus.
pic4550 con oscilador interno.
8 leds conectados en el puerto D.


para refrescar el tema de los operadores a nivel de bits agrego una pequeña guia con ejemplos.

Código: [Seleccionar]

Operadores a nivel de bit (bitwise operators)
-----------------------------------------------------------------------------------------------------------------------------





-----------------------------------------------------------------------------------------------------------------------------
El operador AND "&" compara dos bits; si los dos son 1 el resultado es 1, en otro caso el resultado será 0.
Ejemplo:

        c1 = 0x45      --> 01000101
        c2 = 0x71      --> 01110001
        ---------------------------
        c1 & c2 = 0x41 --> 01000001





-----------------------------------------------------------------------------------------------------------------------------
El operador OR  "|" compara dos bits; si cualquiera de los dos bits es 1, entonces el resultado es 1; en otro caso será 0. Ejemplo:

        i1 = 0x47      --> 01000111
        i2 = 0x53      --> 01010011
        ---------------------------
        i1 | i2 = 0x57 --> 01010111






-----------------------------------------------------------------------------------------------------------------------------

El operador exclusivo (XOR) "^", da por resultado uno cuando los dos operandos tienen distinto valor.


Cuando los dos operandos son distintos da 1.-
ej: 1 y 0    =1
    0 y 1    =1

Cuando los dos operandos son iguales da 0.-
    0 y 0    =0
    1 y 1    =0

 Ejemplo:

        i1 = 0x47      --> 01000111
        i2 = 0x53      --> 01010011
        ---------------------------
        i1 ^ i2 = 0x14 --> 00010100





-----------------------------------------------------------------------------------------------------------------------------
El operador de complemento a 1 "~" cambia cada dígito del operando por su opuesto:

si el bit es 1 se cambia por 0 y viceversa


        c = 0x45  --> 01000101
        ----------------------
        ~c = 0xBA --> 10111010




-----------------------------------------------------------------------------------------------------------------------------
Los operadores de desplazamiento a nivel de bit "<<" y ">>" Desplazan a la izquierda o a la derecha un número especificado de bits.
En un desplazamiento a la izquierda los bits que sobran por el lado izquierdo se descartan y se rellenan los nuevos espacios con ceros. De manera análoga pasa con los desplazamientos a la derecha. Veamos un ejemplo:

  c = 0x1C 00011100

c << 1 c = 0x38 00111000
c >> 2 c = 0x07 00000111

Como en binario se trabaja en base dos cada posición de desplazamiento implica dividir o multiplicar por 2

>> divide por 2.

<< multiplica por 2

c = 0x1C 00011100

c << 1 c = 0x38 00111000 multiplica por 2
c >> 2 c = 0x07 00000111 divide 2 veces por 2 (divide por 4)








Dependiendo el compilador El operador shift   >> tiene diferente comportamiento
--------------------------------------------------------------------------------
depende del tipo de dato al que se le va a aplicar. Más precisamente si la variable fue creada con signo o sin signo.


EJEMPLO:
creamos dos variables

unsigned char A=100;
signed char B=-100;




Valor de A= 100 // valor decimal
Valor de A en binario: 01100100
Valor de A en binario luego de aplicarle shift >> 2:
Valor en binario:      00011001 // en este caso el bit más significativo se indica con un cero.
                                //  y los bits que se desplacen hacia la derecha del bit más significativo
                                // se completan con ceros 0.

Valor de B= -100 // valor decimal
Valor de B en binario: 10011100
Valor de B en binario luego de aplicarle shift >> 2:
Valor de B en binario: 11100111 // en este caso el bit más significativo se mantiene para indicar el signo negativo
                                // y los bits que se desplacen hacia la derecha del bit más significativo
                                // se completan con unos 1.


-----------------------------------------------------------------------------------------------------------------------------
ejemplos de precedencia de los operandos:


puerto &= ~(1<<6) primero se desplaza un 1 hacia la izquierda 6 posiciones y luego el operando ~ lo convierte en cero. Es resultado se combina mediante el operando & con el contenido del byte del puerto. Aplicándose así una máscara que pone en cero el bit 6 dejando pasar los demás bits. De esta manera se logra un equivalente en assembler de bitclr en la posición del bit 6.





#define bit_set(bit,puerto) (puerto |= 1<<bit)
#define bit_clr(bit,puerto) (puerto &= ~(1<<bit))



// ejemplo en código
bit_set(0,PORTB); // pone a 1 el bit 0 del puerto B.
bit_clr(0,PORTB); // pone a 0 el bit 0 del puerto B.





-----------------------------------------------------------------------------------------------------------------------------
Código binario en complemento a dos:

En este sistema, los números positivos se representan reservando el bit más significativo (que debe ser cero) para el signo. Para los números negativos, se utiliza un sistema distinto, denominado complemento a dos, en el que se cambian los bits que serían 0 por 1 y viceversa, y al resultado se le suma uno.
Este sistema sigue reservando el bit más significativo para el signo, que sigue siendo 1 en los negativos. Por ejemplo, la representación de 33 y -33 sería:

    +33    0010 0001
         se invierte todo
    -33    1101 1110
         se le suma 1
         + 0000 0001
          resultado
           1101 1111   numero -33 en complemento a dos

El hardware necesario para implementar operaciones aritméticas con números representados de este modo es mucho más sencillo que el del complemento a uno, por lo que es el sistema más ampliamente utilizado.
-----------------------------------------------------------------------------------------------------------------------------



PARA ROTAR UN BYTE


C language does not specify a rotate operator; however, it does allow shifts. The compiler will detect expressions that implement rotate operations using shift and logical operators and compile them efficiently.

EJEMPLO:
c = (c << 1) | (c >> 7);







    Saludos.
       Jukinch

[jukinch]

comparto guia de estudio sobre proyectos con múltiples archivos y ámbito de variables. No está en xc8 pero es C y servirá para comprender los conceptos en xc8.
Está en confección. De a poco se irá puliendo.
Saludos.
         Jukinch

[jeremylf]

Gracias por sus respuestas. En estos días haré mas pruebas en base a todo lo expuesto haber si sale como quiero. Nuevamente, gracias.

[ottanawa]

Hola a todos!! Soy nuevo en éste foro y también estoy comenzando en este lenguaje de programación. Vengo del ccs pic, y bueno en realidad quería saber como hacer para configurar los fuses para un circuito simple de encender y apagar un led con el pic 18f46j50, porque he visto por ejemplo el 18f45j50, pero cuando yo lo realizo, el delay que me realiza es el doble de lo calculado. Desde ya muchas gracias y espero su pronta respuesta

[ottanawa]

Hola a todos! Soy nuevo en este foro, y bueno me estoy iniciando en XC8. Estoy teniendo problemas para declarar los fuses para un pic: 18f46j50. Lo que quiero realizar es solamente un circuito sencillo, prender y apagar un led. Pero como tengo problemas con la declaración de los fuses, no lo puedo realizar. Desde ya estaría agradecido si me pueden a solucionar el problema. Saludos

[Suky]

Hola! Podes revisar la documentación especifica para ese micro: doc/pic18_chipinfo.html...



Saludos!

[electroipod]

Hola amigo queria saber si tu libreria i2c puede manejar el ds1307, y tambien quería saber si esta libreria lo sacaste de algun lugar o lo hiciste tu.

[AngelGris]

Hola amigo queria saber si tu libreria i2c puede manejar el ds1307, y tambien quería saber si esta libreria lo sacaste de algun lugar o lo hiciste tu.

  ¿A cuál librería te refieres? Yo subí una de I2C por software, por ello la pregunta. En el caso de mi librería, trabaja a una velocidad aproximada de 70Khz y la velocidad máxima para el modo standard es de 100KHz así que supongo que funcionaría, a no ser que necesite una mayor velocidad.

[Rseliman]

Hola amigo queria saber si tu libreria i2c puede manejar el ds1307, y tambien quería saber si esta libreria lo sacaste de algun lugar o lo hiciste tu.

  ¿A cuál librería te refieres? Yo subí una de I2C por software, por ello la pregunta. En el caso de mi librería, trabaja a una velocidad aproximada de 70Khz y la velocidad máxima para el modo standard es de 100KHz así que supongo que funcionaría, a no ser que necesite una mayor velocidad.

Yo use la libreria de Angelgris y anda perfecto ...la use en un BMP085 de bosh ...es un sensor de presion ...Saludos

[Rseliman]

Hola a todos ...

Desde hace unos dias me estoy volviendo loco con el Mplabx y xc8 ...no he querido preguntar porque siempre trato de googlear antes de hacerlo , pero la verdad es que me tiene cansado ..

Estoy usando un pic 18f2550 ..y un lcd de nokia 5110 ...el cual se comunica por SPI ...googleando encontre una libreria que pareciera funcionara bien , al menos viendola deberia ...pero el tema es que no puedo acceder a la SPI.h ...al compilar compila todo bien , pero por ejemplo si veo la SPI.h esta toda comentada ...es como si el compilador no agrega el pic18xx.h ...les paso la libreria y sigo comentando

Código: [Seleccionar]

#include <xc.h>
#include <stdio.h>
#include <stdlib.h>
#include <delays.h>
#include <spi.h>
#include "5110lcd.h"


   #define SCE_5110  LATBbits.LATB3
   #define RESET_5110 LATBbits.LATB2
   #define DC_5110 LATBbits.LATB4



 const char font[] = {0x00, 0x00, 0x00, 0x00, 0x00, // 20 space
    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 55
    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};


  void LCD5110_init(void)
{
    Delay10KTCYx(20);
    SCE_5110 = 0; // Enable the 5110 device (Active Low)
    RESET_5110 = 0; // Reset the device. Again, active low
    Delay10KTCYx(20); // Delay 20ms to make sure its ok!
    RESET_5110 = 1;

    OpenSPI(SPI_FOSC_16, MODE_00, SMPEND );

    LCD5110_send(0x20 + 0x01, 0); // Extended instructions enabled
    LCD5110_send(0x80 + 0x40, 0); // Set contrast 0 - 127
    LCD5110_send(0x04 + 0x02, 0); // Temperature control
    LCD5110_send(0x10 + 0x03, 0); // Set bias system
    LCD5110_send(0x20 + 0x00, 0); // Return to basic instruction set, power on, set horizontal addressing
    LCD5110_send(0x08 + 0x04, 0); // Display control set to normal mode
}

void LCD5110_send(unsigned char data, unsigned char dc)
{
    DC_5110 = dc; // Set the appropriate status for command=0 or data=1
    putcSPI (data);
}

void LCD5110_cls(unsigned char b_w)
{
    unsigned int i;
    unsigned char bg;

    if (b_w == 0) // set the background color
    {
        bg = 0x00;
    }
    else if (b_w == 1)
    {
        bg = 0xFF;
    }

    LCD5110_send(0x40, 0); // set Y address
    LCD5110_send(0x80, 0); // set X address
    for (i = 0; i < 504; i++)
    {
        LCD5110_send(bg, 1); // Clear everything
    }
}

void LCD5110_sendchar(unsigned char character)
{
    unsigned char column = 0;
    character = character - 0x20; // 0x20 is the first element of the array

    for (column = 0; column < 5; column++) // Pass through each column
    {
        LCD5110_send(font[(int) character * 5 + column], 1);
    }

    LCD5110_send(0x00, 1); // Send a small space
}

void LCD5110_sendstring(const char *str)
{
    while (*str) // pass through each character
    {
        LCD5110_sendchar(*str); // and send it
        str++;
    }

     }


la libreria compila perfectamente bien ...

el headers es el siguiente

Código: [Seleccionar]

void LCD5110_init(void);
void LCD5110_send(unsigned char data, unsigned char dc);
void LCD5110_cls(unsigned char b_w);
void LCD5110_sendchar(unsigned char character);
void LCD5110_sendstring(const char *str);



pero cuando pongo el mouse en putcspi (data) y mantengo apretado control ...me deberia llevar a esa funcion ...
y sin embargo me pone no puedo habrir el elemento putcspi ...

si habro SPI.h ...es como que si no interpreta los prototipos de las funciones ....y si sigo para atras en pconfig.h ....tambien esta todo comentado como que si no interpretaria el pic18f2550 ....no se si me explico ....perdon si me expreso mal


Ojala alguno pueda darme una mano porque esto me ha vuelto loco ...estoy usando el xc8 v1.20

Gracias a todos

[jukinch]

Hola rodrigo.
Probaste poner la línea del include del pic al comienzo?
#include <pic18f2550.h>
Hubo algunas veces que agregándola se me solucionaron los problemas.
No debería ser así porque xc.h se encarga de ello pero con probar no se pierde nada.

[Rseliman]

Bueno ...logre solucionarlo ....al menos ahora si saque los comentarios del spi.h

espero a alguien le sirva ...ahora si veo porque no funciona la libreria !!!

agregue en las propiedades del proyecto la macro de esta forma __18f2550

[Rseliman]

Hola rodrigo.
Probaste poner la línea del include del pic al comienzo?
#include <pic18f2550.h>
Hubo algunas veces que agregándola se me solucionaron los problemas.
No debería ser así porque xc.h se encarga de ello pero con probar no se pierde nada.

Gracias Jukinch ...si lo habia hecho pero sin resultados positivos ...

[AngelGris]

  Estuve revisando un poco los headers y es en pconfig.h donde se establece el tipo de ADC, SPI, I2C etc que posee cada pic de la familia 18.
  Para mi poco entendimiento parecería ser que el problema radica en que en dicho header se evalúa si está definido por ejemplo "__18F2550" o "__18F458" y sin embargo en uno de los hedaers correspondientes al pic (p18f2550.h) se define como "__18F2550_H" y en el otro (pic18f2550.h) se define como "_PIC18F2550_H_". En ninguno de los casos concuerda con la evaluación que se realiza en "pconfig.h".