/***********************************************************************/
/*                                                                     */
/*  FILE        :RX210_ADC_DEMO.c                                      */
/*  DATE        :Tue, Jan 27, 2015                                     */
/*  DESCRIPTION :Main Program                                          */
/*  CPU TYPE    :RX210                                                 */
/*                                                                     */
/*  This file is generated by Renesas Project Generator (Ver.4.53).    */
/*  NOTE:THIS IS A TYPICAL EXAMPLE.                                    */
/*                                                                     */
/***********************************************************************/
/******************************************************************************
Includes   <System Includes> , "Project Includes"
******************************************************************************/
#include 	"iodefine.h"

/******************************************************************************
Typedef definitions
******************************************************************************/
char c1[50];
void system_clk(void);
void SCI0_init(void);
void Console_Display(char *pInputStr);
void hw_setup(void);
/******************************************************************************
Macro definitions
******************************************************************************/
void hw_setup1(void);
void seg7_0_9(unsigned int c);
char seg_sw1();
void pull_up();
/******************************************************************************
Imported global variables and functions (from other files)
******************************************************************************/
unsigned short g_tmr_cnt = 0;
unsigned short g_tmr_flag = 0;
/******************************************************************************
Exported global variables and functions (to be accessed by other files)
******************************************************************************/

/******************************************************************************
Private global variables and functions
******************************************************************************/
//void hw_setup(void);
//void system_clk(void);

/******************************************************************************
* Function Name: main
* Description  : main loop function
* Arguments    : none
* Return Value : none
******************************************************************************/
//}]wX
#define P442  PORT4.PDR.BIT.B2//Cq]wX
#define P115  PORT1.PDR.BIT.B5//Cq]wX
#define P116  PORT1.PDR.BIT.B6//Cq]wX
#define P117  PORT1.PDR.BIT.B7//Cq]wX
#define P003  PORT0.PDR.BIT.B3//TLED]wX()
#define P005  PORT0.PDR.BIT.B5//TLED]wX()
#define P007  PORT0.PDR.BIT.B7//TLED]wX()
#define P331  PORT3.PDR.BIT.B1//y]wX
#define P334  PORT3.PDR.BIT.B4//y]wX
#define P440  PORT4.PDR.BIT.B0//X
//TLEDX(PODR)
#define P03  PORT0.PODR.BIT.B3
#define P05  PORT0.PODR.BIT.B5
#define P07  PORT0.PODR.BIT.B7
#define P40  PORT4.PODR.BIT.B0
//C_X(PODR)
#define P42  PORT4.PODR.BIT.B2
#define P15  PORT1.PODR.BIT.B5
#define P16  PORT1.PODR.BIT.B6
#define P17  PORT1.PODR.BIT.B7
//J(PIDR)
#define P32  PORT3.PIDR.BIT.B2 
#define P33  PORT3.PIDR.BIT.B3 
#define P22  PORT2.PIDR.BIT.B2 
#define P23  PORT2.PIDR.BIT.B3 
#define P24  PORT2.PIDR.BIT.B4 
#define P25  PORT2.PIDR.BIT.B5 
#define P26  PORT2.PIDR.BIT.B6 
#define P27  PORT2.PIDR.BIT.B7
//yX(PIDR)
#define P31  PORT3.PODR.BIT.B1
#define P34  PORT3.PODR.BIT.B4
//ɹq(PCR)
#define PU32 PORT3.PCR.BIT.B2
#define PU33 PORT3.PCR.BIT.B3
#define PU22 PORT2.PCR.BIT.B2
#define PU23 PORT2.PCR.BIT.B3
#define PU24 PORT2.PCR.BIT.B4
#define PU25 PORT2.PCR.BIT.B5
#define PU26 PORT2.PCR.BIT.B6
#define PU27 PORT2.PCR.BIT.B7
#define PU31 PORT3.PCR.BIT.B1
#define PU34 PORT3.PCR.BIT.B4
#define PUJ3 PORTJ.PCR.BIT.B3
#define PU41 PORT4.PCR.BIT.B1

//Ƶ{
void delay(unsigned int a)
{
		unsigned int b;
		for(b=0;b<a;b++);
}

//D{
void main(void)
{
	int m=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0;
	hw_setup1();	
	while(1)
	{
	hw_setup();
	pull_up();
	m=seg_sw1();	
	seg7_0_9(m);
	 if(m==0 & a==0)
	 {
		P31=0;
		delay(25000);
		P31=1;
		delay(25000);
		a=a+1;
	 }
	 if(m>0)
	 {
		 a=0;
	 }
	 
	 if(m==2 & b==0)
	 {
		P34=0;
		delay(25000);
		P34=1;
		delay(25000);
		b=b+1;
	 }
	 if(m>2)
	 {
		 b=0;
	 }
	 
	 if(P32==0 & c==0)
	 {
		Console_Display("a");
		c=c+1;
	 }
	 if(P32==1)
	 {
		 c=0;
	 }
	 
	 if(P33==0 & d==0)
	 {
		Console_Display("b");
		d=d+1;
	 }
	 if(P33==1)
	 {
		 d=0;
	 }
	 
	 if(P22==0 & e==0)
	 {
		Console_Display("c");
		e=e+1;
	 }
	 if(P22==1)
	 {
		 e=0;
	 }
	 
	 if(P23==0 & f==0)
	 {
		Console_Display("d");
		f=f+1;
	 }
	 if(P23==1)
	 {
		 f=0;
	 }
	 
	 if(P24==0 & g==0)
	 {
		Console_Display("e");
		g=g+1;
	 }
	 if(P24==1)
	 {
		 g=0;
	 }
	 
	 if(P25==0 & h==0)
	 {
		Console_Display("f");
		h=h+1;
	 }
	 if(P25==1)
	 {
		 h=0;
	 }
	 
	 if(P26==0 & i==0)
	 {
		Console_Display("g");
		i=i+1;
	 }
	 if(P26==1)
	 {
		 i=0;
	 }
	 
	 if(P27==0 & j==0)
	 {
		Console_Display("h");
		j=j+1;
	 }
	 if(P27==1)
	 {
		 j=0;
	 }
	 
	}
}

void hw_setup1(void)
{
	/* Set P14 as a output pin */
	P442 = 1;//seg7//
	P115 = 1;//seg7//
	P116 = 1;//seg7//
	P117 = 1;//seg7//
	
	P003 = 1;//LED_RED//
	P007 = 1;//LED_BLUE//
	P005 = 1;//LED_GREEN//
	
	P331 = 1;//Sound
	P334 = 1;//Sound
	//P440 = 1;
} /* End of function hw_setup() */

//Cq0_9ܽX
void seg7_0_9(unsigned int c)
{
	switch(c)
	{
	case 0:
	P42 = 0;P15 = 0;P16 = 0;P17 = 0; /*0*/
	delay(10000);
	break;
	case 1:
	P42 = 1;P15 = 0;P16 = 0;P17 = 0; /*1*/
	delay(10000);
	break;
	case 2:
	P42 = 0;P15 = 1;P16 = 0;P17 = 0; /*2*/
	delay(10000);
	break;
	case 3:
	P42 = 1;P15 = 1;P16 = 0;P17 = 0; /*3*/
	delay(10000);
	break;
	case 4:
	P42 = 0;P15 = 0;P16 = 1;P17 = 0; /*4*/
	delay(10000);
	break;
	case 5:
	P42 = 1;P15 = 0;P16 = 1;P17 = 0; /*5*/
	delay(10000);
	break;
	case 6:
	P42 = 0;P15 = 1;P16 = 1;P17 = 0; /*6*/
	delay(10000);
	break;
	case 7:
	P42 = 1;P15 = 1;P16 = 1;P17 = 0; /*7*/
	delay(10000);
	break;
	case 8:
	P42 = 0;P15 = 0;P16 = 0;P17 = 1; /*8*/
	delay(10000);
	break;
	}
}

//L}}(^ǥOD{Cqʧ@)
char seg_sw1()
{
	int m=0 ;
	if(P32 == 0)
	m=m+1;
	if(P33 == 0)
	m=m+1;
	if(P22 == 0)
	m=m+1;
	if(P23 == 0)
	m=m+1;
	if(P24 == 0)
	m=m+1;
	if(P25 == 0)
	m=m+1;
	if(P26 == 0)
	m=m+1;
	if(P27 == 0)
	m=m+1;
	
	if(m==0)
	{
	P03 = 1;//LED_RED//
	P05 = 0;//LED_GREEN//
	P07 = 0;//LED_BLUE//
	hw_setup();
	Console_Display("0");	
	}
	
	if(m==1)
	{
	hw_setup();
	Console_Display("1");
	}
	if(m==2)
	{
	hw_setup();
	Console_Display("2");
	}
	if(m==3)
	{
	hw_setup();
	Console_Display("3");
	}
	if(m==4)
	{
	hw_setup();
	Console_Display("4");
	}
	if(m==5)
	{
	hw_setup();
	Console_Display("5");
	}
	if(m==6)
	{
	hw_setup();
	Console_Display("6");
	}
	if(m==7)
	{
	hw_setup();
	Console_Display("7");
	}
	if(m==8)
	{
	hw_setup();
	Console_Display("8");
	}
	if(m>0&&m<8)
	{
	P07 = 1;//LED_BLUE//
	P03 = 0;//LED_RED//
	P05 = 0;//LED_GREEN//	
	}
	
	if(m==8)
	{
	P05 = 1;//LED_GREEN//
	P03 = 0;//LED_RED//
	P07 = 0;//LED_BLUE//system_clk();	
	}
	return m;
	
}

void pull_up()
{
	PU32=1;
	PU33=1;
	PU22=1;
	PU23=1;
	PU24=1;
	PU25=1;
	PU26=1;
	PU27=1;
	PU31=1;
	PU34=1;
	PU41=1;
}


void hw_setup(void)
{
	/* SCKCR setting */
	system_clk();

	/* Set P14 as a output pin */
	SCI0_init();
	

} /* End of function hw_setup() */

void system_clk(void)
{
	unsigned int i;
	
	SYSTEM.PRCR.WORD = 0x0A503;			/* Protect Register Off */
	SYSTEM.SYSCR0.WORD=0x5A01;			/* External BUS disabled */
  	MPC.PWPR.BYTE = 0x00; MPC.PWPR.BYTE = 0x40;  /* allow writing to MPC PFS */
 	RTC.RCR3.BYTE = 0x0C;               /* sub clock oscillator drive ability => standard */
	

  {
    /* PLL @50Mhz from 20Mhz xtal */
    SYSTEM.OPCCR.BIT.OPCM = 0x0; /* high speed mode */
    while(SYSTEM.OPCCR.BIT.OPCMTSF == 1)
      ;
      
  	SYSTEM.MOSCCR.BYTE = 0x00;			/* EXTAL ON :(Bit0=0F)main clock oscillates */
  	for(i = 0;i< 1250;i++)
      ;				/* Wait 10mS */
      
  	SYSTEM.PLLCR.WORD=0x0901;			/* PLL circuit (x10/2)=>20.0MHzx10/2=100Mhz */
  	SYSTEM.PLLWTCR.BYTE	=0x08;			/* Set waitiQ1Qng time (0x08:32768cycle) */
  	SYSTEM.PLLCR2.BIT.PLLEN=0;			/* turn on PLL */
    
  	for(i = 0;i< 1250;i++);				/* Wait 10mS */
   
  	SYSTEM.SCKCR.LONG = 0x21821211;
	/*                    || | | |    PLL  division ratio */
	/*                 FCLK| | | |    100Mhz/ 4 = 25Mhz */
	/*                  ICLK | | |    100Mhz/ 2 = 50Mhz */
	/*                    BCLK | |    100Mhz/ 4 = 25Mhz */
	/*                     PCLKB |    100Mhz/ 4 = 25Mhz */
	/*                       PCLKD    100Mhz/ 2 = 50Mhz */


  	SYSTEM.SCKCR3.WORD = 0x0400;		/* Select PLL circuit */
	
	SYSTEM.SYSCR0.WORD=0x5A03;			/*enable external bus to view BCLK Output on BCLK Pin P53*/
  }
	
} /* End of function system_clk() */

/******************************************************************************
* ID                : 1.0
* Outline           : Initial setting of SCI
* Include           : 
* Declaration       : void SCI_init(void)
* Description       : 
* Argument          : none
* Return Value      : none
* Calling Functions : none
******************************************************************************/
void SCI0_init(void)
{
	unsigned int i;
	/* Enable writing to MPC pin function control registers */
    MPC.PWPR.BIT.B0WI = 0;
    MPC.PWPR.BIT.PFSWE = 1;
	MPC.P20PFS.BIT.PSEL = 0xA;
	MPC.P21PFS.BIT.PSEL = 0xA;
	MPC.PWPR.BIT.PFSWE = 0;
	MPC.PWPR.BIT.B0WI = 1;
	
	PORT2.PMR.BYTE = 0x03;				/*Set P20, P21 for peripheral functions.*/	

	MSTP(SCI0) =0;
	/* Step 1 */
	SCI0.SCR.BYTE = 0x00; /* Clear bits TIE, RIE, TE, RE, and TEIE in SCR to 0 */

	/* Step 2 */
	SCI0.SCR.BYTE = 0x00;			/* set initial value */
	
	/* Step 3 */
	SCI0.SIMR1.BIT.IICM = 0;	/* Serial interface mode */
	SCI0.SPMR.BIT.CKPH = 0;		/* Clock is not delayed. */
	SCI0.SPMR.BIT.CKPOL = 0;	/* Clock polarity is not inverted */
	
	SCI0.SMR.BYTE = 0x00;			/* PCLK(25MHz) */
									/* Stop bit = 1 */
									/* non parity */
									/* Character Length = 8 bit */
									/* Asynchronous communication */
									/* Multi-processor communications function is disabled*/

	SCI0.SCMR.BYTE = 0xF2;			/* set initial value */
	SCI0.SEMR.BIT.ABCS = 1;			/* Selects 8 base clock cycles for 1-bit period*/
	/* Step 4 */
	SCI0.BRR = 161;					/* Bitrate(38400bps) */
	
	/* Step 5 */	
	for(i=0;i<1000;i++);			/* Waiting at time of one bit or more of sending */
	
	/* Step 6 */					/* and receiving clock                           */
	SCI0.SCR.BYTE = 0xF0;			/* TE, TIE, RE, RIE is enabled */

//	PORTB.ICR.BIT.B6 = 1;
	/* interupt initial setting */ 
	ICU.IPR[0xD6].BYTE = 0x01;  	
	ICU.IER[0x1A].BIT.IEN7 = 1; 
	
}/**/

/******************************************************************************
* Function Name: Console_Display
* Description  :
* Arguments    : none
* Return Value : none
******************************************************************************/
static void SCI_RcvError(void);

#define COMSOLE_DLY 100000

void Console_Display(char *pInputStr)
{
        unsigned int delay_t;

        while(*pInputStr)
        {
                SCI0.TDR = pInputStr[0];
                *pInputStr++;
                for(delay_t = 0; delay_t < COMSOLE_DLY; delay_t++); 
               
			//	if(!*pInputStr)
			//	{
			//		SCI2.TDR = 0x0D;
			//		for(delay_t = 0; delay_t < COMSOLE_DLY; delay_t++); 
			//		SCI2.TDR = 0x0A;
			//		for(delay_t = 0; delay_t < COMSOLE_DLY; delay_t++); 
			//	}

                SCI_RcvError();
        }
}

/******************************************************************************
* Function Name: SCI2_RXI2
* Description  : Receive data from PC and save data in buffer register
* Arguments    : none
* Return Value : none
******************************************************************************/
void SCI0_RXI0(void)
{

	c1[0]= SCI0.RDR;

	Console_Display(c1);
	
	SCI_RcvError();
}
	
/******************************************************************************
* Function Name: SCI_RcvError
* Description  :
* Arguments    : none
* Return Value : none
******************************************************************************/
void SCI_RcvError(void)
{
        unsigned char tmp;

        if(SCI0.SSR.BIT.ORER ==1)
        {       /* Overrun error processing */
                tmp = SCI0.RDR;
                SCI0.SSR.BYTE = 0x00;            /* SCI0 ORER FER PER flag clear */
                
        }
        else if(SCI0.SSR.BIT.FER ==1)
        {
                /* Framing error processing */
        }
        else if(SCI0.SSR.BIT.PER ==1)
        {
                /* Parity error processing */
        }
        
}

