/******************************************************************************

  This program is a sample for 78K0S/KA1+ 8-bit Single-Chip Microcontrollers.

  Copyright(C) NEC Electronics Corporation 2004, 2005
  All rights reserved by NEC Electronics Corporation.

  This program should be used on your own responsibility.
  NEC Electronics Corporation assumes no responsibility for any losses
  incurred by customers or third parties arising from the use of this file.

  Filename :  uart_samplesession.c
  Device :    uPD78F9222
  Compiler :  NEC/CC78K0

  Description:  This sample program simulates a voltage meter with serial
                communication channel. The sample program does a cyclic
                measurement of the input voltage of AD converter channel 0,
                port P20/ANI0, and transfers the measured result via UART6
                to a terminal program running at the host machine. The data
                transfer speed is set to 115200 bps per default. The input
                voltage can be changed by potentiometer R24.

*******************************************************************************/

#pragma sfr
#pragma di
#pragma ei
#pragma interrupt INTTM80 vect_INTTM80
#pragma interrupt INTAD vect_INTAD

/*-----------------------------------------------------------------------------
   Include files
------------------------------------------------------------------------------*/

/*-----------------------------------------------------------------------------
   Definition of Option Byte
------------------------------------------------------------------------------*/
#pragma section @@CNST OPT AT 80H
const char OPTION = 0x9A;
                     /* Shortest stabilisation time 2^10/fx */
                     /* RESET pin is used as is External clock input */
                     /* shortest stabilisation time 2^10/fx */
                     /* Ring osc can be stopped */

/*-----------------------------------------------------------------------------
   Global Defines
------------------------------------------------------------------------------*/

/****************************  chose baudrate   *******************************/
#if 0
#define BAUDRATE 9600
#define BAUDRATE 38400
#else
#define BAUDRATE 115200
#endif

/*-----------------------------------------------------------------------------*/
#define LED1   P2.3    	    /* LED D1 */
#define LED2   P13.0        /* LED D2 */
#define LED3   P4.5         /* LED D3 */
#define LED4   P12.3        /* LED D4 */

/*-----------------------------------------------------------------------------
   Global variables
------------------------------------------------------------------------------*/
unsigned char result_out;
unsigned char result10;
unsigned char result1;
unsigned char result01;

/*-----------------------------------------------------------------------------
   Function prototyps
------------------------------------------------------------------------------*/
void drive_LED(unsigned char value);

/*-----------------------------------------------------------------------------
   Module:   init_CPU
   Function: Initialization of CPU
------------------------------------------------------------------------------*/
void init_CPU (void)
{
    WDTM = 0x70;        /* stop watchdog timer */

  /* time gererator settings */
    PCC = 0x00;         /* set CPU time to fx */
    PPCC = 0x00;

    LSRCM = 0x01;       /* low speed ring oscillator stops */

    OSTS  = 0x00;       /* shortest stabilisation time 2^10/fx */

  /* interrupt setting */
    IF0  = 0x00;
    IF1  = 0x00;
    MK0  = 0xFF;
    MK1  = 0xFF;
}

/*-----------------------------------------------------------------------------
   Module:   init_LED
   Function: Initialization of LED ports
------------------------------------------------------------------------------*/
void init_LED (void)
{
    PMC2.3=0;           /* set port mode control of P23 to port mode */
    PM2.3=0;            /* set port P23 to output mode -> LED1 */
    PM4.5=0;            /* set port P45 to output mode -> LED3 */
    PM12.3=0;           /* set port P123 to output mode -> LED4 */

    LED1=0;     	    /* drive LED1 */
    LED2=0;             /* drive LED2 */
    LED3=0;             /* drive LED3 */
    LED4=0;             /* drive LED4 */

    LED1=1;             /* switch LED1 off */
    LED2=1;             /* switch LED2 off */
    LED3=1;             /* switch LED3 off */
    LED4=1;             /* switch LED4 off */
}

/*-----------------------------------------------------------------------------
   Module:   init_ADC
   Function: Initialization of AD converter
------------------------------------------------------------------------------*/
void init_ADC (void)
{
    PMC2.0=1;           /* set alternate function mode */
    PM2.0=1;            /* set port to input mode */

    ADIF = 0;           /* clear interrupt request flag */
    ADMK = 0;           /* enable ADC interrupt */
}

/*-----------------------------------------------------------------------------
   Module:   init_UART
   Function: Initialization of UART6
------------------------------------------------------------------------------*/
void init_UART(void)
{
    PM4.4=1;                /* input mode for RxD */
    PM4.3=0;                /* output mode for TxD */
    P4.3=1;                 /* set TxD output to high level */

#if BAUDRATE==9600          /* initialization for baudrate = 9600 */
    CKSR6 = 0x02;
    BRGC6 = 104;
#elif BAUDRATE==38400       /* initialization for baudrate = 38400 */
    CKSR6 = 0x00;
    BRGC6 = 104;
#elif BAUDRATE==115200      /* initialization for baudrate = 115200 */
    CKSR6 = 0x00;
    BRGC6 = 35;
#endif

    POWER6 = 1;             /* enable internal clock operation */

    ASIM6 |= 0xE5;          /* enable transmission */
                            /* enable reception */
                            /* no parity */
                            /* character lenght of data = 8-bits */
                            /* number of stop bits = 1 */
}

/*-----------------------------------------------------------------------------
   Module:   init_TM80
   Function: Initialization of Timer80
------------------------------------------------------------------------------*/
void init_TM80(unsigned char interval)
{
    TCE80 = 0;              /* stop timer80 */
    TMC80 = 0x06;           /* set input clock to fxp / 2^10 7.81Khz @ 8MHz */
    CR80  = interval;       /* set interval time */
    TCE80 = 1;              /* start timer80 */
    TMIF80 = 0;             /* clear interrupt request flag */
    TMMK80=0;               /* enable timer80 interrupt */
}

/*-----------------------------------------------------------------------------
   Module:   UART_SendChar
   Function: Send char via UART6
------------------------------------------------------------------------------*/
void UART_SendChar (unsigned char ucData)
{
    TXB6 = ucData;          /* load UART transmit buffer */
    while(!STIF6);          /* wait for transmission finished */
    STIF6=0;
}

/*-----------------------------------------------------------------------------
   Module:   UART_GetChar
   Function: Get char from UART6
------------------------------------------------------------------------------*/
unsigned char UART_GetChar(void)
{
    unsigned char receive_byte;
    while(!SRIF6);               /* wait for uart receive byte */
    receive_byte = RXB6;         /* load UART receive buffer */
    SRIF6=0;
    return (receive_byte);
}

/*-----------------------------------------------------------------------------
   Module:   UART_SendString
   Function: Send string via UART6
------------------------------------------------------------------------------*/
void UART_SendString (char *ucpStr)
{
    unsigned char ucData;
    while (1)
    {
       	ucData = (unsigned char)(*ucpStr++);
        if(ucData){
		    UART_SendChar (ucData);
		}
        else{
            break;
        }
    }
}

/*-----------------------------------------------------------------------------
   Module:   UART_SendResult
   Function: Send measured result via UART6
------------------------------------------------------------------------------*/
void UART_SendResult(void)
{
    UART_SendString("Voltage = ");
    UART_SendChar(result10+0x30);
    UART_SendString(".");
    UART_SendChar(result1+0x30);
    UART_SendChar(result01+0x30);
    UART_SendString(" V\r");
    drive_LED(result10);
    result_out = 0;
}

/*-----------------------------------------------------------------------------
   Module:   wait
   Function: generates a wait loop
------------------------------------------------------------------------------*/
__callt void wait(void)
{
    char a=0;
    while(a!=0xff)
    {
        a++;
    }
}

/*-----------------------------------------------------------------------------
   Module:   main
   Function: main program
------------------------------------------------------------------------------*/
void main(void)
{
    DI();               /* global interrupt disable */

    init_CPU();         /* cpu initialization */
    init_LED();         /* led port initialization */
    init_UART();        /* uart60 initialization */

    UART_SendString("***************************************\n\r");
    UART_SendString("*                                     *\n\r");
    UART_SendString("*         K_Line    78K0S/KA1+        *\n\r");
    UART_SendString("*                                     *\n\r");
    UART_SendString("*         Low Pin Count - Do it!      *\n\r");
    UART_SendString("*                                     *\n\r");
    UART_SendString("***************************************\n\n\r");
    UART_SendString("Press a key to start voltage measuring!\n\n\r");

    UART_GetChar();     /* wait for uart receive byte */

    UART_SendString("***************************************\n\n\r");

    init_ADC();         /* adc initialization */
    init_TM80(60);      /* initialization of timer80 */

    EI();               /* global interrupt enable */

    while(1)
    {
        wait();
        if (result_out) UART_SendResult();
    }
}

/*-----------------------------------------------------------------------------
   ISR: 	 vect_INTTM80
   Function: Interrupt service routine of Timer80
------------------------------------------------------------------------------*/
__interrupt void vect_INTTM80(void)
{
    ADCE = 1;           /* enable voltage generator */
    ADS  = 0x00;        /* AD channel select */
    ADCS = 1;           /* start conversion */
}

/*-----------------------------------------------------------------------------
   ISR: 	 vect_INTAD
   Function: Interrupt service routine of ASD converter
------------------------------------------------------------------------------*/
__interrupt void vect_INTAD(void)
{
    unsigned short result;
    unsigned char temp;

    result = ADCRH;     /* load AD conversion result */
    ADCS = 0;           /* stop AD converter */
    ADCE = 0;           /* disable voltage generator */

    result=result<<1;            /* convert AD result for */
    result10 = result/100;       /* decimal output */
    result1  = result%100;
    temp = result1;
    result1  = result1/10;
    result01   = temp % 10;
    result_out = 1;
}

/*-----------------------------------------------------------------------------
   Module:   drive_LED
   Function: Output of 4-bit value to LED port
------------------------------------------------------------------------------*/
void drive_LED(unsigned char value)
{
    LED1 =~(value>>3);
    LED2 =~(value>>2);
    LED3 =~(value>>1);
    LED4 =~(value);
}