//******************************************************************************************
//  PIC12F1822 Sample Program
//   Project      :
//   Program Name :
//   Programer    :
//   Create date  :  Version 1.0    H24.12.18
//   History      :
//   Laungage     :  HI_TECH PICC C Laungage Version 9.83
//******************************************************************************************
//   Description
//        OSC : Internal OSC 16MHz
//        I/O : USART  RA(5):Rx, RA(4):Tx
//              CPLD   RA(2):Data,  RA(1):Data_clock,  RA(0):Mode
//******************************************************************************************
#include	<stdio.h>
#include	<string.h>
#include	<stdlib.h>
#include	<math.h>
#include	<ctype.h>
#include	<htc.h>
__CONFIG(  FOSC_INTOSC & WDTE_OFF & PWRTE_OFF &  MCLRE_OFF & CP_OFF & CPD_OFF 
                       & BOREN_OFF & CLKOUTEN_OFF & IESO_OFF & FCMEN_OFF );
__CONFIG(  WRT_OFF & PLLEN_OFF & STVREN_OFF & BORV_HI & LVP_OFF ) ;
//
#define PI_NORMAL   0
#define PI_FAILER   1
#define PI_OSC      40000000    //[Hz]
#define PI_OUTMIN   1           //[Hz]
#define PI_VHDL_DOT 200
#define PI_LONG_BIT 32
//
void InitUART(void);
char SendUART(unsigned char);
char RecUART(unsigned char *);
void SendUART_s(char *);
void CPLD_Send_data(unsigned long, unsigned int);
void UART_getdata(unsigned long *);
void Init_message(void);
void Put_message(unsigned long);
void CPLD_Send_data_bits(unsigned char);
void CPLD_Send_data_load(void);
void nops(void);

unsigned char Init_msg1[]=" frequency";
unsigned char Init_msg2[]="[Hz]";
unsigned char Init_msg3[]=" SET:";
unsigned char temp_line[10];

void main()
{
    unsigned long freq;
    unsigned long freq_loop;
    unsigned long dummy = 0;

// *****************************
//   1.Initialized Segment
// *****************************
// (1)Define OSC (16MHz, IntOSC)
    OSCCON = 0b11111010;

// (2)Define ANSELA (ALL Digital Port)
    ANSELA = 0x00;

// (3)Define I/O port
    TRISA = 0b11111000;
    PORTA = 0b00000000;

// (4)Define APFCON Register
//      APFCON:RXDTSEL.SDOSEL,SSSEL,---,T1GSEL,TXCKSEL,P1BSEL,CCP1SEL
//        BSF     APFCON,RXDTSEL  ; RX ==> RA5
//        BSF     APFCON,TXCKSEL  ; TX ==> RA4
    APFCONbits.RXDTSEL = 1;
    APFCONbits.TXCKSEL = 1;

// (5)Initialized EUART
    InitUART();

// (6)Demo Message
    Init_message();

// *****************************
//   2.Program main
// *****************************
    while(1){
// (1)Get frequency
        while(1){
            UART_getdata(&freq);
            if( freq <= ( (unsigned long)PI_OSC / (unsigned long)PI_VHDL_DOT / (unsigned long)2 ) 
             && freq >= PI_OUTMIN )break;
            SendUART  ('?');
        }
// (2)Calculate loop
        freq_loop = (unsigned long)PI_OSC / (unsigned long)PI_VHDL_DOT / (unsigned long)2 / freq ; 
        freq = (unsigned long)PI_OSC  / (unsigned long)PI_VHDL_DOT / (unsigned long)2 / freq_loop ;
        Put_message(freq);
 // (3)Send data
        freq_loop = freq_loop ;
        CPLD_Send_data(dummy,     (unsigned int)PI_LONG_BIT);                        //Dummy data
        CPLD_Send_data((freq_loop - (unsigned long)1), (unsigned int)PI_LONG_BIT);   //Data
        CPLD_Send_data_load();                                                       //Data load 
    }
}

//******************************************************************************************
//   Function Name : Init_message
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void Init_message(void)
{
    SendUART_s(Init_msg1);
    SendUART  (' ');

    sprintf(temp_line,"%ld",(unsigned long)PI_OSC /  (unsigned long)PI_VHDL_DOT /(unsigned long)2);
    SendUART_s(temp_line);
    SendUART_s(Init_msg2);
    SendUART  ('-');

    sprintf(temp_line,"%ld",(unsigned long)PI_OUTMIN);
    SendUART_s(temp_line);
    SendUART_s(Init_msg2);
    SendUART  ('?');
    SendUART  (' ');
}

//******************************************************************************************
//   Function Name : Put_message
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void Put_message(unsigned long freq)
{
    SendUART_s(Init_msg3);
    sprintf(temp_line,"%ld",freq);
    SendUART_s(temp_line);
    SendUART_s(Init_msg2);
    SendUART(' ');
}

//******************************************************************************************
//   Function Name : UART_getdata
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void UART_getdata(unsigned long *feq)
{
    unsigned char  IO_char;

    *feq = 0;

    while(1){
        while(1){
            RecUART(&IO_char);
            if(( 0x30 <= IO_char ) && ( IO_char <= 0x39)){
                SendUART(IO_char);
                *feq = *feq * 10 + (unsigned long)(IO_char & 0x0f);
                break;
            }else if(IO_char == 0x20){
                return;
            }
        }
    }
}

//******************************************************************************************
//   Function Name : CPLD_Send_data
//   Title         : 
//   Input         : 
//   Output        :
//   Description   : unsigned long : 32bits
//******************************************************************************************
void CPLD_Send_data(unsigned long send_data, unsigned int data_max)
{
    unsigned int lp;

    for(lp=0;lp<data_max;lp++){
        if((send_data & 0x80000000) != 0x00000000){
             CPLD_Send_data_bits(1);
//           SendUART('1');
        }else{
             CPLD_Send_data_bits(0);
//           SendUART('0');
        }
        send_data = send_data << 1 ; 
    }
//  SendUART(' ');
}

//******************************************************************************************
//   Function Name : CPLD_Send_data_bits
//   Title         : 
//   Input         : 
//   Output        :
//   Description   : unsigned long : 32bits
//******************************************************************************************
void CPLD_Send_data_bits(unsigned char bits)
{
    if(bits == 0){
        PORTA &= 0b11111011;
        nops();
        PORTA |= 0b00000010;
        nops();
        PORTA &= 0b11111101;
    }else{
        PORTA |= 0b00000100;
        nops();
        PORTA |= 0b00000010;
        nops();
        PORTA &= 0b11111101;
    }
}

//******************************************************************************************
//   Function Name : CPLD_Send_data_load
//   Title         : 
//   Input         : 
//   Output        :
//   Description   : unsigned long : 32bits
//******************************************************************************************
void CPLD_Send_data_load(void)
{
    nops();
    PORTA |= 0b00000001;
    nops();
    PORTA &= 0b11111110;
}

//******************************************************************************************
//   Function Name : SendUART_s
//   Title         : Send UART String
//   Input         : 
//   Output        :
//******************************************************************************************
void SendUART_s(char *put_string)
{
    while(*put_string!=0x00){
        SendUART(*put_string);
        put_string++;
    }
}

//******************************************************************************************
//   Program       : InitUART
//   Title         : Initialize UART
//   Input         :
//   Output        :
//   Description   : Fosc:16MHz, Baud Rate:9600BPS, 16-bit Baud Rate
//******************************************************************************************
void InitUART(void){
// *******************************************************
// 1.Define TXSTA(TRANSMIT STATUS AND CONTROL) Register   
//   TXSTA(7) CSRC: Clock Source Select bit
//        Asynchronous mode:Donft care
//   TXSTA(6) TX9: 9-bit Transmit Enable bit
//         1 = Selects 9-bit transmission
//         0 = Selects 8-bit transmission
//   TXSTA(5) TXEN: Transmit Enable bit(1)
//         1 = Transmit enabled
//         0 = Transmit disabled
//   TXSTA(4) SYNC: EUSART Mode Select bit
//         1 = Synchronous mode
//         0 = Asynchronous mode
//   TXSTA(3) SENDB: Send Break Character bit
//     Asynchronous mode:
//         1 = Send Sync Break on next transmission (cleared by hardware upon completion)
//         0 = Sync Break transmission completed
//   TXSTA(2) BRGH: High Baud Rate Select bit
//     Asynchronous mode:
//         1 = High speed
//         0 = Low speed
//   TXSTA(1) TRMT: Transmit Shift Register Status bit
//         1 = TSR empty
//         0 = TSR full
//   TXSTA(0) TX9D: Ninth bit of Transmit Data
//        Can be address/data bit or a parity bit.
// *******************************************************
    TXSTA = 0b00100100;

// *******************************************************
// 2.Define RCSTA(RECEIVE STATUS AND CONTROL) Register   
//    RCSTA(7) SPEN: Serial Port Enable bit
//         1 = Serial port enabled (configures RX/DT and TX/CK pins as serial port pins)
//         0 = Serial port disabled (held in Reset)
//    RCSTA(6) RX9: 9-bit Receive Enable bit
//         1 = Selects 9-bit reception
//         0 = Selects 8-bit reception
//    RCSTA(5) SREN: Single Receive Enable bit
//      Asynchronous mode:
//           Donft care
//    RCSTA(4) CREN: Continuous Receive Enable bit
//      Asynchronous mode:
//         1 = Enables receiver
//         0 = Disables receiver
//    RCSTA(3) ADDEN: Address Detect Enable bit
//      Asynchronous mode 9-bit (RX9 = 1):
//         1 = Enables address detection, enable interrupt and load the receive buffer when RSR<8> is set
//         0 = Disables address detection, all bytes are received and ninth bit can be used as parity bit
//      Asynchronous mode 8-bit (RX9 = 0):
//        Donft care
//    RCSTA(2) FERR: Framing Error bit
//      1 = Framing error (can be updated by reading RCREG register and receive next valid byte)
//      0 = No framing error
//    RCSTA(1) OERR: Overrun Error bit
//      1 = Overrun error (can be cleared by clearing bit CREN)
//      0 = No overrun error
//    RCSTA(0) RX9D: Ninth bit of Received Data
//      This can be address/data bit or a parity bit and must be calculated by user firmware.
// *******************************************************
    RCSTA = 0b10010000;

// *******************************************************
// 3.Define BAUDCON(BAUD RATE CONTROL) Register
//    BAUDCON(7) ABDOVF: Auto-Baud Detect Overflow bit
//      Asynchronous mode:
//        1 = Auto-baud timer overflowed
//        0 = Auto-baud timer did not overflow
//    BAUDCON(6) RCIDL: Receive Idle Flag bit
//      Asynchronous mode:
//        1 = Receiver is Idle
//        0 = Start bit has been detected and the receiver is active
//    BAUDCON(5) Unimplemented: Read as e0f
//    BAUDCON(4) SCKP: Synchronous Clock Polarity Select bit
//      Asynchronous mode:
//        1 = Transmit inverted data
//        0 = Transmit non-inverted data
//    BAUDCON(3) BRG16: 16-bit Baud Rate Generator bit
//        1 = 16-bit Baud Rate Generator is used (SPBRGH:SPBRG)
//        0 = 8-bit Baud Rate Generator is used (SPBRG)
//    BAUDCON(2) Unimplemented: Read as e0f
//    BAUDCON(1) WUE: Wake-up Enable bit
//      Asynchronous mode:
//        1 = Receiver is waiting for a falling edge. No character will be received but RCIF will be set on 
//            the falling edge. WUE will automatically clear on the rising edge.
//        0 = Receiver is operating normally
//    BAUDCON(0) ABDEN: Auto-Baud Detect Enable bit
//      Asynchronous mode:
//        1 = Auto-Baud Detect mode is enabled (clears when auto-baud is complete)
//        0 = Auto-Baud Detect mode is disabled
// *******************************************************
    BAUDCON = 0b00001000;

// *******************************************************
// 3.Define BRG(EUSART Baud Rate Generator Register) Register
// *******************************************************
//  BRG = 16000000(Hz)/4/9600(BPS)-1 ==> 0d0416 ==> 0x1A0 
// (1)Define SPBRGH(EUSART Baud Rate Generator Register, High Byte) Register
    SPBRGH = 0x01;

// (2)Define SPBRG(EUSART Baud Rate Generator Register, Low Byte) Register
    SPBRG = 0xA0;

}

//******************************************************************************************
//   Program       : RecUART
//   Title         : Recive UART
//   Input         :
//   Output        : 
//******************************************************************************************
char RecUART(unsigned char *IO_data)
{
    unsigned char status;
   
// ****************************  
//  1.Check Recvive Flag
// ****************************
// (1)Clear RCIF
    PIR1 = PIR1 & 0b11111011;

// (2)Check RCIF
    while(1){
        status = PIR1 & 0x20;
        if(status != 0x00)break;
    }
 
// ****************************  
//  2.Check error
// ****************************
    status = RCSTA & 0x06; //0000,0110 RCSTA(FERR,OERR)  
    if(status != 0x00){
        *IO_data = 0x00;
        return(PI_FAILER);
    }

// ****************************  
//  3.Set Recive Data
// ****************************
    *IO_data = RCREG;
    return(PI_NORMAL);
}

//******************************************************************************************
//   Program       : SendUART
//   Title         : Send UART
//   Input         : 
//   Output        :
//******************************************************************************************
char SendUART(unsigned char IO_data)
{
unsigned char status;

// ***************************  
//  1.Check Send Flag
// ***************************
    while(1){
        status = TXSTA & 0x02; //0000,0010 TXSTA(TRMT)
        if(status != 0x00)break;
    }

// ***************************
//  2.Set data
// ***************************
    TXREG = IO_data;

    return(PI_NORMAL);
}


//******************************************************************************************
//   Function Name : nops
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void nops(void)
{
    unsigned int lp;

    for(lp=0;lp<100;lp++){
        asm("nop");
    }
}