programmazione PIC 18f452 tramite MPLAB

#include<p18f452.h>

#pragma config LVP=OFF
#pragma config OSC=HS
#pragma config WDT=OFF

#define idle SSPCON2bits.ACKEN | SSPCON2bits.RCEN | SSPCON2bits.PEN | SSPCON2bits.RSEN | SSPCON2bits.SEN | SSPCON2bits.ACKSTAT | SSPSTATbits.R_W

void Enable(void);
void Waitms(int);
void Waitus(int);
void ConfigTMR(void);
void ConfigI2C(void);
int Trasmissione(void);
int ADconversion(void);

void Riga1(void);
void Riga2(void);
void Inizializza(void);
void Writechar(char*);
void Writeint(int);
void Scrivitemp_LCD(void);
void Scrivitens_LCD(void);

void scrivi_usart(int);
int leggi_usart(void);
void config_usart(void);

void main(){
        T0CON=0;
        TRISC=24;
        TRISD=0;
        PORTC=0;
        PORTD=0;



________cose_che_servono_sempre____________________

void Enable(void){
          PORTCbits.RC3=1;
          Nop();
          PORTCbits.RC3=0;
                 }


void Waitms(int flg){
             int  num = 0xFFFF-(flg*1000);
             TMR0H=num/256;
             TMR0L=num-(num/256)*256;
             T0CONbits.TMR0ON=1;
             while(!INTCONbits.TMR0IF);
             INTCONbits.TMR0IF=0;
             T0CONbits.TMR0ON=1;
                    }


void Waitus(int flg){
             int num = 0xFFFF-(flg);
             TMR0H=num/256;
             TMR0L=num-(num/256)*256;
             T0CONbits.TMR0ON=1;
             while(!INTCONbits.TMR0IF);
             INTCONbits.TMR0IF=0;
             T0CONbits.TMR0ON=1;
                    }


void ConfigTMR(void){
             T0CON=0;
             T0CONbits.T08BIT=0;
             T0CONbits.PSA=1;
                    }


void ConfigI2C(void){
             SSPCON1=0x28;
             SSPSTATbits.SMP=1;
             SSPSTATbits.CKE=1;
             SSPADD=0x09;
                    }



________TEMPERATURA_____________________

int Trasmissione(void){
               int dato;
            SSPCON2bits.SEN=1;
            while(idle);
            SSPBUF=0b10011010;
            while(idle);
            SSPBUF=0x00;
            while(idle);
            SSPCON2bits.RSEN=1;
            while(idle);
            SSPBUF=0b10011011;
            while(idle);
            SSPCON2bits.RCEN=1;
            while(idle);
            dato=SSPBUF;
            SSPCON2bits.ACKDT=1;
            SSPCON2bits.ACKEN=1;                          
            while(idle);
            SSPCON2bits.PEN=1;
            while(idle);
            return dato;
              }


void Scrivitemp_LCD(void){
              int dato;
              char temp[12]={"TEMPERATURA"};


              unsigned int u;
              unsigned int d;
              unsigned int c;
              unsigned int m;
                   
              Riga1();
              Writechar(temp);
              while(1){
                       dato=Trasmissione();
                       Riga2();
       
                      m=dato/1000;
                     c=(dato-m*1000)/100;
                    d=(dato-m*1000-c*100)/10;
                      u=(dato-m*1000-c*100-d*10);
                                     
                      m=m+0x30;   
                      c=c+0x30;
                      d=d+0x30;
                      u=u+0x30;
                                         
                      Writeint(m);
                      Writeint(c);
                      Writeint(d);
                      Writeint(u);
                      }
            }


________TENSIONE______________________


int ADconversion (void){
            int dato;
            //ACCENSIONE
            ADCON0bits.ADON=1;
           
              //CONFIGURO I PIN
            ADCON1bits.PCFG3=1;
            ADCON1bits.PCFG2=1;
            ADCON1bits.PCFG1=1;
            ADCON1bits.PCFG0=0;                           
            ADCON1bits.ADFM=1;
                               
            //SELEZIONO IL CANALE DI INGRESSO
            ADCON0bits.CHS2=0;
            ADCON0bits.CHS1=0;
            ADCON0bits.CHS0=0;
                               
            //SELEZIONO IL CLOCk
            ADCON1bits.ADCS2=0;
            ADCON0bits.ADCS1=0;
            ADCON0bits.ADCS0=1;
                               
            //START CONVERSIONE
            ADCON0bits.GO=1;
                               
            //Attendo la fine della conversione.
            while(ADCON0bits.GO==1);
                               
            dato=ADRESH*256 + ADRESL;
                               
            return dato;
            }



void Scrivitens_LCD (void){
            int dato;
            unsigned int d;
            unsigned int c;
            unsigned int m;
            unsigned int u;
            char temp[14]={"COD.   VALUE."};
            char spazio[4]={"___"};
            char punt[2]={"."};

            Riga1();
            Writechar(temp);
                   
            while(1){           
                 dato=ADconversion();
                 Riga2();
                 dato=ADconversion();
                       
                 m=dato/1000;
                 c=(dato - m*1000)/100;
                 d=(dato - m*1000 - c*100)/10;
                 u= dato - m*1000 - c*100 - d*10;
                               
                 m=m+0x30;
                 c=c+0x30;
                 d=d+0x30;
                 u=u+0x30;
                               
                 Writeint(m);
                 Writeint(c);
                 Writeint(d);
                 Writeint(u);
                               
                 Writechar(spazio);
                               
                 dato=dato*4.887;                               
                 m=dato/1000;
                 c=(dato - m*1000)/100;
                 d=(dato - m*1000 - c*100)/10;
                 u= dato - m*1000 - c*100 - d*10;
                                
                      m=m+0x30;
                 c=c+0x30;
                 d=d+0x30;
                 u=u+0x30;
                               
                 Writeint(m);
                 Writechar(punt);
                 Writeint(c);
                 Writeint(d);
                 Writeint(u);
                    }      
           }



________TERMINALE_VIRTUALE________________________


void config_usart(void){
            PORTCbits.RC7=1;
            PORTCbits.RC6=0;
            RCSTAbits.SPEN=1;//Serial Port Enable bit
            TXSTAbits.BRGH=1;//High Baud Rate Selcet bit (1=>High speed)
            SPBRG=25;
            }

void scrivi_usart(int dato){   
                TXREG=dato;
                while(!PIR1bits.TXIF);
                Waitms(9000);
               }

int leggi_usart(void){   
              while(!PIR1bits.RCIF);
              return RCREG;
             }


________LCD______________________
void Writechar(char* dato){
            int i=0;
            PORTCbits.RC1=1;
            PORTCbits.RC2=0;
            while(dato[i]!=0){
                      PORTD=dato[i];
                      Enable();
                      Waitus(100);
                      i++;
                     }
                  }

void Writeint(int dato){
            PORTCbits.RC1=1;
            PORTCbits.RC2=0;
            PORTD=dato;
            Enable();
            Waitms(100);
                    }

void Inizializza(void){
            PORTCbits.RC0=1;
            Waitms(20);
            PORTCbits.RC1=0;
            PORTCbits.RC2=0;
                    PORTD=0b01100000;
            Enable();
            Waitms(5);
            PORTD=0b01100000;
            Enable();
            Waitus(100);
            PORTD=0b01100000;
            Enable();
            Waitus(100);
            PORTD=0b00111000;
            Enable();
            Waitus(100);
            PORTD=0b00001000;
            Enable();
            Waitus(100);
            PORTD=0b00000110;
            Enable();
            Waitus(100);

            PORTD=0b00001111;
            Enable();
            Waitus(100);
              }

void Riga1(void){
         PORTCbits.RC1=0;
         PORTD=0x80;
         Enable();
         Waitms(100);
        }

void Riga2(void){
         PORTCbits.RC1=0;
         PORTD=0xc0;
         Enable();
         Waitms(100);
        }


________MAIN_____________
void main(){
    int dato;
    int riemp;
    short int i, j;
    unsigned int u, u1;
    unsigned int d, d1;
    unsigned int c, c1;
    unsigned int m, m1;
    int mig[7];
    int cen[7];
    int dec[7];
    int uni[7];
    int buf[7];
    int max, min, med;
    short int app1;
    short int app2;
   
    ConfigI2C();
    ConfigTMR();
    config_usart();
           
    TXSTAbits.TXEN=1;//Transmission Enable bit
    RCSTAbits.CREN=1;//Continuos Receive Enable bit

    while(!Trasmissione());
           
    max=0;
    min=1000;
    med=0;

    while(i<5){
        dato=Trasmissione();             
        buf[i]=dato;         
        m=(dato/1000);
        c=(dato-m*1000)/100;
        d=(dato-m*1000-c*100)/10;
        u=(dato-m*1000-c*100-d*10);
                         
        m=m+0x30;   
        c=c+0x30;
        d=d+0x30;
        u=u+0x30;
       
        mig[i]=m;
        cen[i]=c;
        dec[i]=d;
        uni[i]=u;
                       
        if(buf[i]>max){
                max=buf[i];
                app1=i;
                   }   

        if(min>buf[i]){
                app2=i;
                min=buf[i];
                  }
                       
        med=med+buf[i];
        i++;
                                       
        while(dato==Trasmissione());
        }

    med=med/5;

    m1=(med/1000);
    c1=(med-m1*1000)/100;
    d1=(med-m1*1000-c1*100)/10;
    u1=(med-m1*1000-c1*100-d1*10);       
    m1=m1+0x30;   
    c1=c1+0x30;
    d1=d1+0x30;
    u1=u1+0x30;
           
    scrivi_usart(mig[app1]);
    scrivi_usart(cen[app1]);
    scrivi_usart(dec[app1]);
    scrivi_usart(uni[app1]);
    scrivi_usart(0x20);
    scrivi_usart(0x20);
    scrivi_usart(mig[app2]);
    scrivi_usart(cen[app2]);
    scrivi_usart(dec[app2]);
    scrivi_usart(uni[app2]);       
    scrivi_usart(0x20);
    scrivi_usart(0x20);
    scrivi_usart(m1);
    scrivi_usart(c1);
    scrivi_usart(d1);
    scrivi_usart(u1);
    while(1);       
       }