/* THIS SAMPLE CODE IS PROVIDED AS IS AND IS SUBJECT TO ALTERATIONS. FUJITSU */
/* MICROELECTRONICS ACCEPTS NO RESPONSIBILITY OR LIABILITY FOR ANY ERRORS OR */
/* ELIGIBILITY FOR ANY PURPOSES.                                             */
/*                 (C) Fujitsu Microelectronics Europe GmbH                  */
/*---------------------------------------------------------------------------
  MAIN.C
  - description
  - See README.TXT for project description and disclaimer.

/*---------------------------------------------------------------------------*/

#include "mb90340.h"
#include "LCD.h"

#define LED1 PDR0_P00
#define LED2 PDR0_P01
#define LED3 PDR0_P02
#define LED4 PDR0_P03
#define LED5 PDR0_P04
#define LED6 PDR0_P05
#define LED7 PDR0_P06
#define LED8 PDR0_P07

#define DELAY_LED 20000L


void InitUart0(void)
{
  // Initialize UART asynchronous mode
  BGR0 = 1666; //  9600 Baud @ 16MHz
  // BGR0 = 832;  // 19200 Baud @ 16MHz
  // BGR0 = 416;  // 38400 Baud @ 16MHz

  // BGR0 = 2083; //  9600 Baud @ 20MHz
  // BGR0 = 1041; // 19200 Baud @ 20MHz
  // BGR0 = 520;  // 38400 Baud @ 20MHz

  // BGR0 = 2499; //  9600 Baud @ 24MHz
  // BGR0 = 1249; // 19200 Baud @ 24MHz
  // BGR0 = 624;  // 38400 Baud @ 24MHz
   
  SCR0 = 0x17; // 8N1
  SMR0 = 0x0d; // enable SOT0, Reset, normal mode
  SSR0 = 0x00; // LSB first
}

void Putch0(char ch)         /* sends a char */
{
  while (SSR0_TDRE == 0);    /* wait for transmit buffer empty 	*/
  TDR0 = ch;                 /* put ch into buffer			*/
}

unsigned char Getch0(void)     /* Waits for and returns incomming char */
{
  unsigned char rxchar;
  
  for(;;)
  {

    while(SSR0_RDRF == 0)      /* Wait for data received  	           */
    {
      __wait_nop(); 
    }

    rxchar = RDR0;             /* Save receive register                */

    if ((SSR0 & 0xE0) != 0)    /* Check for errors PE, ORE, FRE        */
    {
      SCR0_CRE = 1;            /* Clear error flags 	               */
    }
    else
    {
      return (rxchar);         /* Return received character            */
    }

  }
  
}



void Puts0(const char *Name2)  /* Puts a String to UART */
{
  int i,len;
 
  len = strlen(Name2);
	
  for (i=0; i<strlen(Name2); i++)   /* go through string                     */
  {
    if (Name2[i] == 10)
      Putch0(13);
    Putch0(Name2[i]);               /* send it out                           */
  }
}


void InitUart2(void)
{
  // Initialize UART asynchronous mode
  BGR2 = 1666; //  9600 Baud @ 16MHz
  //BGR2 = 2499; // 9600 Baud @ 24MHz
  SCR2 = 0x17; // 8N1
  SMR2 = 0x0d; // enable SOT2, Reset, normal mode
  SSR2 = 0x00; // LSB first
}

void Putch2(char ch)         /* sends a char */
{
  while (SSR2_TDRE == 0);    /* wait for transmit buffer empty 	*/
  TDR2 = ch;                 /* put ch into buffer			*/
}

unsigned char Getch2(void)     /* Waits for and returns incomming char */
{
  unsigned char rxchar;
  
  for(;;)
  {

    while(SSR2_RDRF == 0)      /* Wait for data received  	           */
    {
      __wait_nop(); 
    }

    rxchar = RDR2;             /* Save receive register                */

    if ((SSR2 & 0xE0) != 0)    /* Check for errors PE, ORE, FRE        */
    {
      SCR0_CRE = 0;            /* Clear error flags 	                 */
    }
    else
    {
      return (rxchar);         /* Return received character            */
    }

  }
  
}



void Puts2(const char *Name2)  /* Puts a String to UART */
{
  int i,len;
 
  len = strlen(Name2);
	
  for (i=0; i<strlen(Name2); i++)   /* go through string                     */
  {
    if (Name2[i] == 10)
      Putch2(13);
    Putch2(Name2[i]);              /* send it out                           */
  }
}


/*===========================================================================*/
/*====== CAN ================================================================*/
/*===========================================================================*/
/*       Search for "<<<" There changes by the user may be required          */

#define TIMEOUT 50000    /* <<< timeout value, if CAN-data can not be send   */

/*===========================================================================*/
/*====== CAN 0 ==============================================================*/
/*===========================================================================*/

#define	BTR_16M_100k_20_70_3	0x5CC7
#define	BTR_20M_100k_20_70_3	0x5CC9
#define	BTR_24M_100k_20_70_3	0x5CCB


void CAN0_init(void)
{
  CSR0         = 0x81;                /* bit 7: enable transmit output pin   */
                                      /* bit 0: stop bus operation           */
  while (!CSR1_HALT);
  
  TCANR0       = 0xffff;              /* cancel all Transmissions            */
  BVALR0       = 0;                   /* all message buffer are invalid      */
  BTR0         = BTR_16M_100k_20_70_3;/* <<< set bit timing                  */
  CSR0         = 0x0080;              /* activate can bus operation          */

  Puts0("\nCAN Connecting...");
  Puts2("\nCAN Connecting...");
  while (CSR0_HALT);                  /* wait for Bus-connection             */
  Puts0("ok!\n");
  Puts2("ok!\n");
    
  AMR00       = 0;                    /* <<< acceptance mask definition 0    */
  AMR10       = 0;                    /* <<< acceptance mask definition 1    */
}


/*===== CAN Buffer ======= */

/* it is recommended not to use Buffer0 in general, 
   in order to prevent from Hit&Away trap           */

void CAN0_buffer1(void)
{
  /* CAN: messagebuffer 1 will be used as receive-buffer                     */
  
  BVALR0_BVAL1 = 0;       /* message buffer are invalid                      */

  IDER0_IDE1   = 0;       /* <<< 0:11bit 1:29bit indentifier                 */

  IDR0(1)      = 0x4000;  /* <<< ID e.g. 0x4000 = ID #2                      */
                          /*        (11bit-IDs uses Bit 28..18               */
                          /*        (29bit-IDs uses Bit 28...0               */
                          /* see Utility Bitmixer
                          /* or use defines: e.g. IDR(1) = MSG2STD(1);       */

  AMSR0_AMS1   = 1;       /* <<< Acceptance Mask:                            */
                          /* 0 : full bit compare (full can)                 */
                          /* 1 : full bit mask (basic can)                   */
                          /* 2 : use acceptance mask 0                       */
                          /* 2 : use acceptance mask 1                       */

  TIER0_TIE1   = 0;       /* <<< 0: diasble / 1: enable Trx-Interrupt        */

  RFWTR0_RFWT1 = 0;       /* <<< 0: no wait for remote requeset              */

  TRTRR0_TRTR1 = 0;       /* <<< 0: Data / 1: Remote frame Trx               */

  BVALR0_BVAL1 = 1;       /* message buffer are valid                        */
}

void CAN0_buffer6(void)
{
  /* CAN: messagebuffer 6 will be used as send-buffer                     */
  
  BVALR0_BVAL6 = 0;       /* message buffer are invalid                      */

  IDER0_IDE6   = 0;       /* <<< 0:11bit 1:29bit indentifier                 */

  IDR0(6)      = 0x6000;  /* <<< ID e.g. 0x6000 = ID #3                      */
                          /*        (11bit-IDs uses Bit 28..18               */
                          /*        (29bit-IDs uses Bit 28...0               */
                          /* see Utility Bitmixer
                          /* or use defines: e.g. IDR(1) = MSG2STD(1);       */

  AMSR0_AMS6   = 0;       /* <<< Acceptance Mask:                            */
                          /* 0 : full bit compare (full can)                 */
                          /* 1 : full bit mask (basic can)                   */
                          /* 2 : use acceptance mask 0                       */
                          /* 2 : use acceptance mask 1                       */

  TIER0_TIE6   = 0;       /* <<< 0: diasble / 1: enable Trx-Interrupt        */

  RFWTR0_RFWT6 = 0;       /* <<< 0: no wait for remote requeset              */

  TRTRR0_TRTR6 = 0;       /* <<< 0: Data / 1: Remote frame Trx               */

  BVALR0_BVAL6 = 1;       /* message buffer are valid                        */
}