// CONFIG
#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 = ON       // Brown-out Reset Enable bit (BOR enabled)
#pragma config LVP = ON        // 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)


#include <xc.h> //Inclusão do arquivo header xc.h
#include <string.h>
#include <stdlib.h> //Conversões
#include <stdio.h>
#define _XTAL_FREQ 4000000 //Define a frequência de clock utilizada

//Protótipos das funções********************************************************
void lcd_ini();
void lcd_cmd(char cmd);
void lcd_envia_byte(char nivel, char dado);
void lcd_envia_string(char mensagem[]);
void lcd_pos_xy(char x, char y);
void Setup();
void le_peso();
void init_timer();

//DEFINES***********************************************************************
#define TIPO        PORTBbits.RB0  //Pino botão  muda tipo
#define PESAGEM     PORTBbits.RB1  //Pino  botão verifica pesagem
#define SENSORPRE   PORTBbits.RB2  //Pino botão sensor presença (com retenção)
#define LED         PORTBbits.RB3  //Saída que aciona LEDs

#define PESOLIMITETOCO      7.5
#define PESOLIMITETRUCK     12.5
#define PESOLIMITECARRETA   40
//Variáveis*********************************************************************
bit auxTIPO     = 0;    //Auxiliar do botao tipo
bit auxPESAGEM  = 0;    //Auxiliar referente a esta rou nao na pesagem

unsigned int adc  = 0;    //Leitura realizada na porta analogica (PESO)
float        Peso = 0;    //Conversão da leitura analógica para toneladas

unsigned char contTIPO = 0; //Auxilia na escolha do tipo de caminhão

int counter = 0; //Contador do timer 0

void main(void)
{
 Setup(); //Chama tela de configurações

 while(1) //Loop principal
{
     if ((!PESAGEM) && (!SENSORPRE) && (auxPESAGEM == 0)) //Se presisonado pesagem e o
     {                                                    //Caminhão já estiver na posição adequada para isso
         auxPESAGEM = 1;
         switch (contTIPO) //DEPEONDENDO DO TIPO ESCOLHIDO COMPARA COM
        {                  //UM DIFERENTE LIMITE DE PESO
            case 0: if (Peso <= PESOLIMITETOCO) //Se estiver dentro do limite para TOCO
                    {
                       lcd_envia_byte(0, 0x01); //Limpa
                       lcd_pos_xy(5,1);
                       lcd_envia_string("PESO  OK");
                    }
                    else //Se não
                    {
                       lcd_envia_byte(0, 0x01); //Limpa
                       lcd_pos_xy(1,1);
                       lcd_envia_string(" ACIMA  DO PESO ");
                    }
            break;

            case 1: if (Peso <= PESOLIMITETRUCK) //Se estiver dentro do limite para TOCO
                    {
                       lcd_envia_byte(0, 0x01); //Limpa
                       lcd_pos_xy(5,1);
                       lcd_envia_string("PESO  OK");
                    }
                    else //Se não
                    {
                       lcd_envia_byte(0, 0x01); //Limpa
                       lcd_pos_xy(1,1);
                       lcd_envia_string(" ACIMA  DO PESO ");
                    }
            break;

            case 2: if (Peso <= PESOLIMITECARRETA) //Se estiver dentro do limite para TOCO
                    {
                       lcd_envia_byte(0, 0x01); //Limpa
                       lcd_pos_xy(5,1);
                       lcd_envia_string("PESO  OK");
                    }
                    else //Se não
                    {
                       lcd_envia_byte(0, 0x01); //Limpa
                       lcd_pos_xy(1,1);
                       lcd_envia_string(" ACIMA  DO PESO ");
                    }
            break;
        }
     }
     if (SENSORPRE) { auxPESAGEM = 0; }

     if (auxPESAGEM == 0) //Se nao estiver no momento de pesagem
     {
        //Escrevendo o tipo de caminhão e o peso atual
        lcd_pos_xy(1,1);
        lcd_envia_string("Peso: ");
        lcd_pos_xy(1,2);
        lcd_envia_string("Tipo: ");

        le_peso(); //Chama a função que realiza leitura da analógica

        //Mostrando PESO no LCD
        unsigned char BufLCD[10];                 //Vetor p/ armazenamento de strings p/ o LCD
        sprintf(BufLCD,"%.2f  TON", Peso);  //Armazena em buffer a string a ser enviada ao LCD
        if (Peso < 10)
        {
            lcd_pos_xy(7,1);
            lcd_envia_string("0");              //Escreve no LCD
            lcd_pos_xy(8,1);
            lcd_envia_string(BufLCD);              //Escreve no LCD
        }
        else
        {
            lcd_pos_xy(7,1);
            lcd_envia_string(BufLCD);              //Escreve no LCD
        }

        switch (contTIPO) //DEPEONDENDO DO TIPO ESCOLHIDO MOSTRA
        {                 //DIFERENTES TIPOS DE CAMINHÕES
            case 0: lcd_pos_xy(7,2);
                    lcd_envia_string("TOCO      ");
            break;

            case 1: lcd_pos_xy(7,2);
                    lcd_envia_string("TRUCK     ");
            break;

            case 2: lcd_pos_xy(7,2);
                    lcd_envia_string("CARRETA   ");
            break;
        }

        if ((!TIPO) && (auxTIPO == 0) && (SENSORPRE)) //Se pressionar o botão tipo
        {
            auxTIPO = 1;
            contTIPO++; //Troca     1 - TOCO 2 - TRUCK 3 - CARRETA
            if (contTIPO == 3)
            {
                contTIPO = 0;
            }
        }
        if (TIPO) auxTIPO = 0;
     }
}
} //Final da função principal (main)

void le_peso() //Função de leitura de analógica
{
    ADCON0bits.GO = 1; //Inicia a conversão A/D

    while (ADCON0bits.GO); //Aguarda a finalização da conversão

    adc = ADRESH; //Armazena a parte alta do resultado em adc
    adc = (adc << 8) + ADRESL; /*Desloca 8 bits à esquerda e soma com a
    parte baixa do resultado da conversão A/D.*/

    Peso = (adc*0.0488758553); //Conversão de adc para toneladas
}

void interrupt chk_isr() //INTERRUPÇÃO QUANDO
{
    if((TMR0IE)&&(TMR0IF)) //Timer 0 estiver habilitado e der overflow
    {
        TMR0 = 5;
        INTCONbits.TMR0IF=0; //Reseta overflow
        counter++; // Conta

        if (SENSORPRE)
        {
            if (counter >= 500)
            {
              counter = 0;
              LED = !LED;
            }
        }
        else
        {
            if (counter >= 1000)
            {
              counter = 0;
              LED = !LED;
            }
        }
    }
}

void init_Timer()
{
    OPTION_REG = 0x01; // 0x08 = 00000000 - 8 BITS  e PRESSCALER 1:4
                  // RBPU = 0 | INTEDG = 0 | T0CS  = 0 | T0SE  = 0 |
                  // PSA   = 0 | TOPS2  = 0 | TOPS1 = 0 | TOPS0 = 1 |
    INTCON = 0xE0;  // 0xE4 = 11100100
                    // GIE  = 1 | PEIE   = 1 | TMR0IE  = 1 | INT0IE = 0 |
                    // RBIE = 0 | TMR0IF = 0 | INTOIF = 0 | RBIF   = 0 |

    TMR0 = 5; // Turn on T0
}

void Setup()
{
    //Início da função principal (main)
    lcd_ini(); //Inicializa LCD
    lcd_envia_byte(0, 0x01); //Limpa

    TRISB=0b00000111;
    PORTB=0x00; //Poe PORTB em zero

    ADCON0 = 0b11001001; /* Bits 7 e 6 = 1 ? Clock através do oscilador interno
    bits 5, 4 = 0 e 3 = 1 ? Seleção do canal analógico AN1
    bit 1 = 0 ? Conversão A/D não iniciada
    bit 0 = 1 ? Módulo A/D habilitado */

    ADCON1 = 0b10000100; /*Bit 7 = 1 ? Resultado da conversão justificado à
    direita. bits 3, 2, 1 e 0 = 0 ? Referências de tensão pelo VDD e GND*/
    init_Timer(); // Inicia timer 0
}

void lcd_ini()
{ //Incício da função lcd_ini
    char i; //Variável de controle para envio dos comandos
    TRISD = 0b00000000; //Todos os pinos da porta D configurados como saída
    TRISEbits.TRISE1 = 0; //Pino 1 da porta E configurado como saída
    TRISEbits.TRISE0 = 0; //Pino 0 da porta E configurado como saída
    PORTD = 0b00000000; //Toda porta D em nível lógico 0
    PORTEbits.RE0 = 0; //Pino 0 da porta E em nível 0
    PORTEbits.RE1 = 0; //Pino 1 da porta E em nível 0
    __delay_ms(15); //Atraso de 15ms
    //Envia o comando 0x30 ao LCD por 3 vezes, em intervalos de 5ms
    for(i=0;i<=2;i++)
    {
    lcd_cmd(0x30);
    __delay_ms(5);
    }
     lcd_cmd(0x02); //LCD deve trabalhar com 4 bits de dados
     __delay_us(40); //Atraso de 40us
    lcd_cmd(0x28); //Comunicação em 4 bits, display de 2 linhas e matriz 7X5
     __delay_us(40); //Atraso de 40us
    lcd_cmd(0x01); //Limpa a memória do LCD
    __delay_ms(2); //Atraso de 2ms
    lcd_cmd(0x0C); //Liga o display sem cursor
     __delay_us(40); //Atraso de 40us
    lcd_cmd(0x06); //Deslocamento do cursor à direita após um novo caractere
    __delay_us(40); //Atraso de 40us
} //Final da função lcd_ini()

void lcd_cmd(char cmd)
{ //Início da função lcd_cmd
    PORTD = cmd & 0xF0; //Posiciona a parte mais significativa do byte na porta D
    PORTEbits.RE1 = 1; //Coloca o pino 1 da porta E (EN) em 1
    PORTEbits.RE1 = 0; //Coloca o pino 1 da porta E (EN) em 0
     __delay_us(100); //Atraso de 100us

    PORTD = (cmd << 4) & 0xF0; /*Posiciona a parte menos significativa do byte na porta D*/
    PORTEbits.RE1 = 1; //Coloca o pino 1 da porta E (EN) em 1
    PORTEbits.RE1 = 0; //Coloca o pino 1 da porta E (EN) em 0
} //Final da função lcd_cmd

void lcd_envia_byte(char nivel, char dado)
{ //Início da função lcd_envia_byte()
    PORTEbits.RE0 = nivel; //Habilita comando ou escrita para o LCD
    __delay_us(100); //Atraso de 100us
    PORTEbits.RE1 = 0; //Coloca o pino 1 da porta E (EN) em 0
   lcd_cmd(dado); //chama a função lcd_cmd com o parâmetro 'dado'
} //Final da função lcd_envia_byte()

void lcd_envia_string(unsigned char mensagem[])
{
    for (int i=0; i<strlen(mensagem); i++)
    {
     lcd_envia_byte(1, mensagem[i]);
    }
}

void lcd_pos_xy(char x, char y) //Função de posicionamento do cursor
{ char endereco; //Variável de informação para o endereço do cursor
    if (y!=1) //Se o valor de y for 2
    endereco = 0xC0; /*Então endereco vai ser igual a 0xC0 (endereço da segunda linha)*/
    else //Senão
    endereco = 0x80; /*Endereço vai ser igual a 0x80 (endereço da primeira linha)*/

    endereco = (endereco + x) - 1; /*Soma o valor de x à variavel endereco e decrementa 1*/
    lcd_envia_byte(0,endereco); /*Chama a função lcd_envia_byte, com o valor 0,
    informando para o LCD que será enviado um dado e
    este dado está contido na variável endereço*/
}