Mini curso "Programación en XC8"

[AcoranTf]

  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.

OK, eso no esta en mi instalacion, no se si lo habran cambiado. Voy a preparar una cuenta de FTP en mi servidor y te pasare los datos para que me envies todas esas carpetas comprimidas, si te parece bien.

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.

OK, eso no esta en mi instalacion, no se si lo habran cambiado. Voy a preparar una cuenta de FTP en mi servidor y te pasare los datos para que me envies todas esas carpetas comprimidas, si te parece bien.

Saludos.

  Dale, no hay ningún problema

[AcoranTf]

  Dale, no hay ningún problema

Te acabo de enviar un MP.

[AKENAFAB]

Les comparto esta rutina para pwm 10bits.

La utilizo con los pic12F1840,16F

Código: C

1. void PWM_set_DC(uint16_t pwm_DC); // duty cycle 10bits pwm

Código: C

1. /**************************************************************/
2.     void PWM_set_DC(uint16_t pwm_DC){
3.    
4.         uint8_t auxt = 0;
5.         uint8_t ccp_temp = 0;
6.        
7.         auxt = pwm_DC << 4;     // swap byte
8.         auxt &= 0b00110000;     // Enmascara dcb1:dcb0 LSB bits
9.         ccp_temp = CCP1CON & 0b11001111; //Prepara registro temporal
10.         ccp_temp |= auxt;   // cargno nuevos bits a variable temporal
11.         CCPR1L = pwm_DC >> 2;   //MSB actualizo la parte alta
12.         CCP1CON = ccp_temp;    // LSB actualizo 2bits parte baja
13.        
14.     }// pwm_set
15.  
16. /**************************************************************/

Código: C

1. uint16_t duty_cycle;
2.  
3. int main(void) {
4.  
5.     while(1){
6.          
7.         for(duty_cycle = 0; duty_cycle < 512;duty_cycle++){ // 0 t0 50%
8.        
9.             PWM_set_DC(duty_cycle);             // establecer valor pwm
10.  
11.             __delay_ms(10);             // 10ms delay
12.         }//for duty
13.  
14.     }//while loop
15. }//main

[Sebas1010]

Buenas hace tiempo que estoy en el foro pero nunca comente nada, generalmente empece a utilizar el CCS para programar en C los micros. Hace poco empece a meterme en el mundo de Mplab x C8 realice dos librerías para el LCD(16x2/20x4) y el ADC(10bits) para los pic 16f8xxx.
A medida que realice nuevas librerías las iré compartiendo.

Código: [Seleccionar]

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * File: LCD 16x2 y LCD 20x4                                                                             
 * Author: Sebas                                                                                 
 * Comments: Gama de pic 16f8XX                                                         
 * Revision history: 1.0a                                                                         
 * Descripcion: LCD HD44780 o equivalente                             
 * -Lcd_int();//Inicializacion del LCD                                 
 * -Lcd_printf();//Funcion para imprimir lo que queremos ver en el LCD
 * -Lcd_clear();//Funcion para limpiar pantalla                       
 * -Lcd_printf_String();//Funcion para imprimir un string             
 * -Lcd_gotoxy();//Funcion de la posicion de posicion en el LCD                                                                                                                                                                                           
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */                                                                   


#ifndef LCD20x4
#define LCD20x4
       
#define PIN_RS    PORTBbits.RB0
#define TRISBRS   TRISBbits.TRISB0

#define PIN_EN    PORTBbits.RB1
#define TRISBEN   TRISBbits.TRISB1

#define LCD_D4    PORTBbits.RB4
#define LCD_D4_T  TRISBbits.TRISB4

#define LCD_D5    PORTBbits.RB5
#define LCD_D5_T  TRISBbits.TRISB5

#define LCD_D6    PORTBbits.RB6
#define LCD_D6_T  TRISBbits.TRISB6

#define LCD_D7    PORTBbits.RB7
#define LCD_D7_T  TRISBbits.TRISB7
 
/*Declaracion de funciones*/

void Lcd_int();
void Lcd_control_cmd(char);
void Lcd_port(char);
void Lcd_write_data_port(char);
void Lcd_printf(char*);
void Lcd_clear();
void Lcd_printf_String(char*);
void Lcd_gotoxy(char , char);

/*Funciones*/

void Lcd_int() //configuracion para inicializar el LCD
{
    PIN_RS = 0;
    PIN_EN = 0;
    TRISBRS = 0;
    TRISBEN = 0;
    LCD_D4 = 0; 
    LCD_D4_T = 0;

    LCD_D5 = 0; 
    LCD_D5_T = 0;

    LCD_D6 = 0;   
    LCD_D6_T = 0;

    LCD_D7 = 0;
    LCD_D7_T = 0;
   
   
    Lcd_port(0x00);
    __delay_ms(20);
    Lcd_control_cmd(0x03);
    __delay_ms(5);
    Lcd_control_cmd(0x03);
__delay_ms(11);
    Lcd_control_cmd(0x03);
 
    Lcd_control_cmd(0x02);
    Lcd_control_cmd(0x02);
    Lcd_control_cmd(0x08);
    Lcd_control_cmd(0x00);
    Lcd_control_cmd(0x0C);
    Lcd_control_cmd(0x00);
    Lcd_control_cmd(0x06);
   
}

void Lcd_control_cmd(char data) //pines de control para LCD
{
  PIN_RS = 0;             
  Lcd_port(data);
  PIN_EN  = 1;             
  __delay_ms(4);
  PIN_EN  = 0;     
}

void Lcd_port(char data) //
{
if(data & 1)
    {   
LCD_D4 = 1;
    }   
else
    {   
LCD_D4 = 0;
    }   

if(data & 2)
    {   
LCD_D5 = 1;
    }   
else
    {   
LCD_D5 = 0;
    }   
if(data & 4)
    {   
LCD_D6 = 1;
    }   
else
{
        LCD_D6 = 0;
    }
if(data & 8)
    {   
LCD_D7 = 1;
    }   
else
    {   
LCD_D7 = 0;
    }   
}


void Lcd_write_data_port(char data)//Modo de 4 bits LCD
{
    char var;
    char y;
   var = (data & 0x0F);
   y = (data & 0xF0);
   PIN_RS = 1;             
   Lcd_port(y>>4);           
   PIN_EN = 1;
   __delay_us(40);
   PIN_EN = 0;
   Lcd_port(var);
   PIN_EN = 1;
   __delay_us(40);
   PIN_EN = 0;
   
}

void Lcd_printf(char *data)//Funcion para imprimir lo que queremos ver en el LCD
{
    while (*data) // Mientras no sea Null
    {
        Lcd_write_data_port(*data); // Envio el dato al LCD
        data++; // Incrementa el buffer de dato
    }
}
void Lcd_gotoxy(char x, char y)//Funcion de la posicion de posicion en el LCD
{
char temp;
    char dato1;
    char dato2;
if(y == 1)
{
  temp = 0x80 + x - 1;
dato1 = temp >> 4;
dato2 = temp & 0x0F;
        Lcd_control_cmd(dato1);
Lcd_control_cmd(dato2);
}
if(y == 2)
{
temp = 0xC0 + x - 1;
dato1 = temp >> 4;
dato2 = temp & 0x0F;
Lcd_control_cmd(dato1);
    Lcd_control_cmd(dato2);
}
    if(y == 3)
    {
        temp = 0x94 + x - 1;
dato1 = temp >> 4;
dato2 = temp & 0x0F;
Lcd_control_cmd(dato1);
    Lcd_control_cmd(dato2);
    }
    if(y == 4)
    {
        temp = 0xD4 + x - 1;
dato1 = temp >> 4;
dato2 = temp & 0x0F;
Lcd_control_cmd(dato1);
    Lcd_control_cmd(dato2);
    }
}
       

void Lcd_clear()//Funcion para limpiar pantalla
{
    Lcd_control_cmd(0);
    Lcd_control_cmd(1);
}
   
 void Lcd_printf_String(char *data)//Funcion imprime string
{
int i;
for(i=0;data[i]!='\0';i++)
  Lcd_write_data_port(data[i]);
}
 
 /*
 * Guardar caracteres especiales. en la CGRAM
 */
void lcd_put_caracter(char adress, char caracter[]) {
    int i;
    Lcd_control_cmd(0x40 + (adress * 8));
    for (i = 0; i < 8; i++) {
        Lcd_write_data_port(caracter[i]);
    }
}

void Lcd_Shift_Right()
{
    Lcd_control_cmd(0);
    Lcd_control_cmd(1);
Lcd_control_cmd(0x0C);
}

void Lcd_Shift_Left()
{
Lcd_control_cmd(0);
    Lcd_control_cmd(1);
Lcd_control_cmd(0x08);
}

#endif

ADC

Código: [Seleccionar]

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * File: ADC                                                       *             
 * Author: Sebas                                                   *
 * Comments: Gama de pic 16f8XX                                    *
 * Revision history: 1.0a                                          *
 * Descripcion: ADC de resolucion 10bits                           *
 * -ADC_Setup();//Elegir E/analagicas y REF interna o externar     *
 * -ADC_Selec_Fosc();//Seleccion de reloj                          *
 * -ADC_Result_Format_Select();//Justificacion del formato         *
 * -ADC_ON_OFF();//Activa o desactiva el ADC                       *                 
 * -ADC_READ();//Obtiene y calcula el valor del ADC y canal        *
 *  Esta descripta las opciones para elegir en los                 *
 *  #define AN_All_VDD_VSS (ejmplo)                                *                                                                                                                                   
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */                                                                   

#ifndef ADC_H
#define ADC_H

#define AN_All_VDD_VSS  1   
#define AN_ALL_VREFPOS_VSS 2
#define AN4_AN3_AN2_AN1_AN0_VDD_VSS 3
#define AN4_AN3_AN2_AN1_AN0_VREFPOS_VSS 4
#define AN3_AN1_AN0_VDD_VSS 5
#define AN1_AN0_VRESFPOS_VSS 6
#define ALL_SHUT_DOWN_AN 7
#define AN_ALL_VREFPOS_VREFNEG 8
#define AN5_AN4_AN3_AN2_AN1_AN0_VDD_VSS 9
#define AN5_AN4_AN2_AN1_AN0_VREFPOS_VSS 10
#define AN5_AN4_VREFPOS_VREFNEG_AN1_AN0 11
#define AN4_VREFPOS_VRESNEG_AN1_AN0 12
#define VREFPOS_VREFNEG_AN1_AN0 13
#define AN0_VDD_VSS 14
#define AN0_VRREFPOS_VREFNEG 15
#define FOSC2 1
#define FOSC8 2
#define FOSC32 3
#define FRC 4
#define FOSC4 5
#define FOSC16 6
#define FOSC64 7
#define FRC2 8
#define RIGHT 1
#define LETF 0
#define ON 1
#define OFF 2


/*Declaracion de funciones*/
void ADC_Setup(char);
unsigned int ADC_READ(unsigned char);
void ADC_Selec_Fosc(char);
void ADC_Result_Format_Select(char);
void ADC_ON_OFF(char);


void ADC_Setup(char set)
{
    if(set == 1)//Referencia Ref+:Vdd y Ref-:Vss
    {                     
       ADCON1bits.PCFG0 = 0;
       ADCON1bits.PCFG1 = 0;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 0;
       
    }
    if(set == 2)//Referencia Ref+:Vdd y Ref-:Vss
    {
       ADCON1bits.PCFG0 = 0;
       ADCON1bits.PCFG1 = 0;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 1;
    }
    if(set == 3)//Analogicos de AN4 a AN0 con VDD y VSS referencia interna
    {
       ADCON1bits.PCFG0 = 0;
       ADCON1bits.PCFG1 = 0;
       ADCON1bits.PCFG2 = 1;
       ADCON1bits.PCFG2 = 0;   
    }
    if(set == 4)//Analogicos de AN4 a AN0 con Ref externa +(AN3) y VSS referencia interna
    {
       ADCON1bits.PCFG0 = 0;
       ADCON1bits.PCFG1 = 0;
       ADCON1bits.PCFG2 = 1;
       ADCON1bits.PCFG3 = 1;   
    }
    if(set == 5)//Analogicos de AN3, AN1 y AN0 con ref interna VDD y VSS
    {
       ADCON1bits.PCFG0 = 0;
       ADCON1bits.PCFG1 = 1;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 0;   
    }
    if(set == 6)//Analogicos de AN1 y AN0 con Ref externa +(AN3) y VSS referencia interna
    {
       ADCON1bits.PCFG0 = 0;
       ADCON1bits.PCFG1 = 1;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 1;   
    }
    if(set == 7)//Apaga todas las entradas analogicas
    {
       ADCON1bits.PCFG0 = 0;
       ADCON1bits.PCFG1 = 1;
       ADCON1bits.PCFG2 = 1;
       ADCON1bits.PCFG3 = 0;   
    }
    if(set == 8)//Todas analogias pero AN3 es ref positivo y AN2 ref negativa
    {
       ADCON1bits.PCFG0 = 1;
       ADCON1bits.PCFG1 = 0;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 0;   
    }
    if(set == 9)//AN5 a AN0 con referencia VDD y VSS
    {
       ADCON1bits.PCFG0 = 1;
       ADCON1bits.PCFG1 = 0;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 1;   
    }
    if(set == 10)//AN5, AN4, AN2, AN1 y AN0 Ref positovo en AN3 y VSS
    {
       ADCON1bits.PCFG0 = 0;
       ADCON1bits.PCFG1 = 1;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 1;   
    }
    if(set == 11)//AN5, AN4, AN1 y AN0 Ref positovo en AN3 y AN2 Ref negativo
    {
       ADCON1bits.PCFG0 = 1;
       ADCON1bits.PCFG1 = 0;
       ADCON1bits.PCFG2 = 1;
       ADCON1bits.PCFG3 = 1;   
    }
    if(set == 12)//AAN4, AN1 y AN0 Ref positovo en AN3 y AN2 Ref negativo
    {
       ADCON1bits.PCFG0 = 1;
       ADCON1bits.PCFG1 = 1;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 0;   
    }
    if(set == 13)//AN1 y AN0, Ref positovo en AN3 y AN2 Ref negativo
    {
       ADCON1bits.PCFG0 = 1;
       ADCON1bits.PCFG1 = 1;
       ADCON1bits.PCFG2 = 0;
       ADCON1bits.PCFG3 = 1;   
    }
    if(set == 14)//AN0, Referencia VDD y VSS
    {
       ADCON1bits.PCFG0 = 1;
       ADCON1bits.PCFG1 = 1;
       ADCON1bits.PCFG2 = 1;
       ADCON1bits.PCFG3 = 0;   
    }
    if(set == 15)//AN0, Ref positovo en AN3 y AN2 Ref negativo
    {
       ADCON1bits.PCFG0 = 1;
       ADCON1bits.PCFG1 = 1;
       ADCON1bits.PCFG2 = 1;
       ADCON1bits.PCFG3 = 1;   
   }   
}

void ADC_Selec_Fosc(char set2)
{

    if (set2 == 1)
    {       
       ADCON1bits.ADCS2 = 0; 
       ADCON0bits.ADCS1 = 0;
       ADCON0bits.ADCS0 = 0;
    }
    if (set2 == 2)
    {       
       ADCON1bits.ADCS2 = 0; 
       ADCON0bits.ADCS1 = 0;
       ADCON0bits.ADCS0 = 1;
    }
    if (set2 == 3)
    {       
       ADCON1bits.ADCS2 = 0; 
       ADCON0bits.ADCS1 = 1;
       ADCON0bits.ADCS0 = 0;
    }
    if (set2 == 4)
    {       
       ADCON1bits.ADCS2 = 0; 
       ADCON0bits.ADCS1 = 1;
       ADCON0bits.ADCS0 = 1;
    }
    if (set2 == 5)
    {       
       ADCON1bits.ADCS2 = 1; 
       ADCON0bits.ADCS1 = 0;
       ADCON0bits.ADCS0 = 0;
    }
    if (set2 == 6)
    {       
       ADCON1bits.ADCS2 = 1; 
       ADCON0bits.ADCS1 = 0;
       ADCON0bits.ADCS0 = 1;
    }
    if (set2 == 7)
    {       
       ADCON1bits.ADCS2 = 1; 
       ADCON0bits.ADCS1 = 1;
       ADCON0bits.ADCS0 = 0;
    }
    if (set2 == 8)
    {       
       ADCON1bits.ADCS2 = 1; 
       ADCON0bits.ADCS1 = 1;
       ADCON0bits.ADCS0 = 1;
    }
}   
   
  void ADC_Result_Format_Select(char set3)
  {
     
      if (set3 == 0) //justificado a la izquierda
      {
           ADCON1bits.ADFM = 0;   
      }
      if(set3 == 1)//justifiacado a la derecha
      {
          ADCON1bits.ADFM = 1;
      }
  } 
         
  void ADC_ON_OFF(char set4)// //Activamos el ADC   
  {
      if(set4 == 1)
      {
        ADCON0bits.ADON = 1;     
      }
      if (set4 == 2)
      {
        ADCON0bits.ADON = 0;     
      }
  }
 
  unsigned int ADC_READ(unsigned char ch)
  {
    if(ch == 0)
    {
    ADCON0bits.CHS = 0;
    __delay_us(30);
    ADCON0bits.GO_nDONE = 1;
    while(ADCON0bits.GO_nDONE);
    return ((ADRESH<<8)+ADRESL);         
    }
    if(ch == 1)
    {
    ADCON0bits.CHS = 1;
    __delay_us(30);
    ADCON0bits.GO_nDONE = 1;
    while(ADCON0bits.GO_nDONE);
    return ((ADRESH<<8)+ADRESL);
    }
    if(ch == 2)
    {
    ADCON0bits.CHS = 2;
    __delay_us(30);
    ADCON0bits.GO_nDONE = 1;
    while(ADCON0bits.GO_nDONE); 
    return ((ADRESH<<8)+ADRESL);
    }
    if(ch == 3)
    {
    ADCON0bits.CHS = 3;
    __delay_us(30);
    ADCON0bits.GO_nDONE = 1;
    while(ADCON0bits.GO_nDONE);
    return ((ADRESH<<8)+ADRESL);
    }
    if(ch == 4)
    {
    ADCON0bits.CHS = 4;
    __delay_us(30);
    ADCON0bits.GO_nDONE = 1;
    while(ADCON0bits.GO_nDONE);
    return ((ADRESH<<8)+ADRESL);
    }
    if(ch == 5)
    {
    ADCON0bits.CHS = 5;
    __delay_us(30);
    ADCON0bits.GO_nDONE = 1;
    while(ADCON0bits.GO_nDONE);
    return ((ADRESH<<8)+ADRESL);
    }
    if(ch == 6)
    {
    ADCON0bits.CHS = 6;
    __delay_us(30);
    ADCON0bits.GO_nDONE = 1;
    while(ADCON0bits.GO_nDONE);
    return ((ADRESH<<8)+ADRESL);
    }
    if(ch == 7)
    {
    ADCON0bits.CHS = 7;
    __delay_us(30);
    ADCON0bits.GO_nDONE = 1;
    while(ADCON0bits.GO_nDONE);
    return ((ADRESH<<8)+ADRESL);
    } 
  }   
#endif




Ejemplo PIC 16f877a

Código: [Seleccionar]

#include <xc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define _XTAL_FREQ 4000000
#include"lcd4x20.h"
#include"ADC.h"

#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bit (BOR disabled)
#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)
#pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

void main(void)
{
   
    int adc,adc2;
    float a,b;
    char s[20];
    char s2[20];
     
    TRISA=0b0000011;
   //Inicializacion de ADC
   ADC_Setup(AN_ALL_VREFPOS_VSS);
   ADC_Selec_Fosc(FOSC2);
   ADC_Result_Format_Select(RIGHT);
   ADC_ON_OFF(ON);
   //Incializacion del LCD
   Lcd_int();
   Lcd_clear();
       
   while(1)
   {
        adc= ADC_READ0();
        sprintf(s,"ADC:%04d",adc);
        Lcd_gotoxy(1,1);
        Lcd_printf_String(s);
       
       
        adc2= ADC_READ(1);
        sprintf(s,"ADC:%04d",adc2);     
        Lcd_gotoxy(1,2);
        Lcd_printf_String(s);
   }     
}


[Chrisbaf]

gracias por el aporte.

[Sebas1010]

Holas, les consulto por el tema de la memoria eeprom que en esta misma seccion estan las rutina de escritura y lectura, el problema que tengo es que lo logro guardar datos que sean mayores a 255 y necesito por ejemplo guardar valores de 0 a 999 pero no me estoy dando cuenta para modificar esas funciones.

Gracias

[KILLERJC]

Holas, les consulto por el tema de la memoria eeprom que en esta misma seccion estan las rutina de escritura y lectura, el problema que tengo es que lo logro guardar datos que sean mayores a 255 y necesito por ejemplo guardar valores de 0 a 999 pero no me estoy dando cuenta para modificar esas funciones.

Gracias

Crea un puntero a char, asignale la memoria de la variable que tengas mas grande, y de alli usa el puntero para guardar el valor. Algo asi:

(No probe el codigo, ni verifique errores, es solo de guia)

Código: C

1. uint16_t minumero;
2. char * ptr;
3.  
4. ptr = (char *)&minumero;
5. guardareeprom(0,*ptr++);
6. guardareeprom(1, *ptr);
7.  
8.  
9. //Para leerlo:
10.  
11. ptr = (char *)&minumero;
12. leereeprom(0,*ptr++);
13. leereeprom(1, *ptr);

[rigaplast]

Perfecto. ¡Gracias!

Hola amigos, a continuación voy a publicar el mini curso que estoy armando de a poco en el foro uControl. Bienvenidas sugerencias, correcciones y aportes aquí mismo, por Twitter o como sea!

Mini curso "Programación de micros en C desde 0"

Introducción

Hola, hoy empiezo este mini curso de programación de microcontroladores PIC en lenguaje C desde 0. La idea es aprender paso a paso, realizar algunos proyectos simples y sumar conocimientos.

Voy a trabajar sobre el sistema operativo Ubuntu, con software libre o gratuito. Para todos aquellos que utilizan Windows no van a tener inconvenientes porque los paquetes de software son multiplataforma. Voy a utilizar como entorno de desarrollo MPLAB X en conjunto con el compilador XC8. No me voy a detener en la instalación y configuración del IDE y del compilador ya que existen muchos tutoriales sobre esto (por ejemplo). El microcontrolador por ahora es un PIC16F648A salvo indicación contraria!

El curso lo voy realizando sobre la marcha, en parte leyendo libros, en parte dudas consultadas a los expertos en el foro y en parte en experiencias propias. Por este motivo lo verán formarse "online" y a medida que el tiempo me lo permita ire sumando contenido. Les recomiendo que lean el tutorial sobre XC8 que escribió Suky que es un buen punto de partida y el "Tutorial MPLAB C18 Desde Cero". También es de mucha utilidad tener a mano los ejemplos de Microchip para consulta: Microchip Code Examples (12F & 16F).

Indice:

1.1. Estructura de un programa en C
1.2. ¡Hola Mundo! en C (o como hacer destellar un LED)
1.3. Leer un pulsador
1.4. Utilizando PWM
1.5. Uso de funciones
1.6. Variables y tipos de datos
1.7. Usando una interrupción por timer0
1.8. Interrupciones de alta y baja prioridad

Ejemplos y rutinas útiles:

2.1. Ejemplo de uso PIC18F4550, delays y USART
2.2. Escribir y leer una memoria EEPROM
2.3. Rutina para generar pausas extensas
2.4. PIC16F819 controlando un modulo LCD 2x16 - 4 bits
2.5. Conversores ADC/PWM (uso de la función ITOA)
2.6. Uso de I2C por software

Bugs, errores, herramientas:

3.1. Corrección del bug "maldita linea roja"
3.2. Dolor de cabeza con el uso de la librería del LCD xlcd.h
3.3. Integrar Proteus VSM para hacer debug en los proyectos de MPLABX con el plugin Proteus VSM viewer
3.4. View Includes Hierarchy
3.5. View macro expansion
3.6. Generador de código para los "Bits de configuración"

[estebanfolcher]

Buenas tardes.

Tengo un problema, empecé con el cambio de Assembly a c hace unos días y estoy aprendiendo desde 0 aprovechó todo lo que encuentro por ay, para ir avanzando.
Pero me doy cuenta de que a medida que paso de lo simple a lo complicado me salen errores al compilar, los códigos (gran parte de ellos están hechos en versiones antiguas y me temo es ese es el motivo este es el primero a ver si me pueden ayudar.

MPLAB IDE 6.15   XC8 2.45  (C99)

#define <PIC.h>
#define <xc.h>


#define V0 RD0       
unsigned char q;


void interrupt ISR(void)   // aqui marca el error
{
    if(T0IF==1)         
    {
        TMR0=0x13;       
        T0IF=0;           
   
      if(++q>250)       
      {
         q=0;
         V0=!V0;       
      }
    }
}

void main(void)           
{

    TRISD=0B11111110;     
    PORTD=0B00000000;     
    T0CS=0;               
    PSA=0;                 
    PS0=0;                 
    PS1=1;                 
    PS2=0;                 
    TMR0=0x13;             
    T0IF=0;               
    T0IE=1;               
    GIE=1;                 
   
    while(1)               
    {

    }
}

este me da el siguiente error

error : variable has incomplete type 'void'
           

           error: expected ',' after top level declararator

Gracias por las respuestas.

PD; ay alguna hoja donde indique las modificaciones que hace xc8 en sus actualizaciones para poder guiarme yo.
Algo por ejemplo en que diga ( bit ya no funciona ahora es __bit)

[DominusDRR]

¿No te falta un guion bajo?

 interrupt_ISR

[estebanfolcher]

Buenas gracias por la ayuda.


pusssssssss. mas que un guion bajo. Ya lo encontre. Antes era ""void interrupt  ISR (void)"" ahora supongo que por la nueva versión de xc8  es ""void __interrrupt() ISR()""

esto es a lo que me refiero si todos te enseñan de una manera como es que esto cambia tanto, ¿esto no es algo estándar?? cada vez que actualizan es como aprender de 0

Gracias. PD: lo encontré en la misma página de microchip.

[DominusDRR]

Buenas gracias por la ayuda.


pusssssssss. mas que un guion bajo. Ya lo encontre. Antes era ""void interrupt  ISR (void)"" ahora supongo que por la nueva versión de xc8  es ""void __interrrupt() ISR()""

esto es a lo que me refiero si todos te enseñan de una manera como es que esto cambia tanto, ¿esto no es algo estándar?? cada vez que actualizan es como aprender de 0

Gracias. PD: lo encontré en la misma página de microchip.

Deberías leer el manual del compilador