/******************************************************************************/
/* BLINKY.C: LED Flasher for MCB-STR9 Board                                   */
/******************************************************************************/
/* This file is part of the uVision/ARM development tools.                    */
/* Copyright (c) 2005-2006 Keil Software. All rights reserved.                */
/* This software may only be used under the terms of a valid, current,        */
/* end user licence from KEIL for a compatible version of KEIL software       */
/* development tools. Nothing else gives you the right to use this software.  */
/******************************************************************************/

#include <91x_lib.h> 
#include "LCD.h"


extern short AD_last;                     /* Last AD value read in interrupt  */

extern __irq void TIM3_IRQ_Handler(void); /* TIM3 interrupt routine           */
extern __irq void ADC_IRQ_Handler (void); /* ADC  interrupt routine           */

GPIO_InitTypeDef    GPIO_InitStructure;
CAN_InitTypeDef     CAN_InitStructure;

/* buffer for receive messages */
  canmsg RxCanMsg;

  /* used message object numbers */
  enum {
	CAN_TX_MSGOBJ = 0,
	CAN_RX_MSGOBJ = 1
  };

  /* array of pre-defined transmit messages */
  canmsg TxCanMsg[4] = {
	{ CAN_STD_ID,      0x123, 4, { 0x01, 0x02, 0x04, 0x08 } },
	{ CAN_STD_ID,      0x321, 4, { 0xAA, 0x55, 0xAA, 0x55 } },
	{ CAN_EXT_ID, 0x12345678, 8, { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 } }, 
	{ CAN_STD_ID,      0x013, 4, { 0x02, 0x06, 0x20, 0x00 } }
  };

void SCU_Configuration(void)
{


  //SCU_MCLKSourceConfig(SCU_MCLK_OSC);
  SCU_PCLKDivisorConfig(SCU_PCLK_Div2);
  SCU_PLLFactorsConfig(128,25,4);
  SCU_PLLCmd(ENABLE);
  SCU_MCLKSourceConfig(SCU_MCLK_PLL);



  SCU_APBPeriphClockConfig(__CAN, ENABLE);
  SCU_APBPeriphClockConfig(__GPIO0, ENABLE);
  SCU_APBPeriphClockConfig(__GPIO1, ENABLE);
  SCU_APBPeriphClockConfig(__GPIO3, ENABLE);
  SCU_APBPeriphClockConfig(__GPIO5, ENABLE);
  SCU_APBPeriphClockConfig(__GPIO7, ENABLE);
  SCU_APBPeriphClockConfig(__GPIO9, ENABLE);
  SCU_AHBPeriphClockConfig(__VIC, ENABLE);

  SCU_APBPeriphReset(__CAN, DISABLE);
  SCU_APBPeriphReset(__GPIO0, DISABLE);
  SCU_APBPeriphReset(__GPIO1, DISABLE);
  SCU_APBPeriphReset(__GPIO3, DISABLE);
  SCU_APBPeriphReset(__GPIO5, DISABLE);
  SCU_APBPeriphReset(__GPIO7, DISABLE);
  SCU_APBPeriphReset(__GPIO9, DISABLE);
  SCU_AHBPeriphReset(__VIC, DISABLE);
  
  VIC_InitDefaultVectors(); /* initialize VICs default vector registers*/
}

void IO_Init(void)
{

GPIO_DeInit(GPIO5);

/* P5.1 alternate input 1, CAN_RX */
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1;
GPIO_InitStructure.GPIO_Direction=GPIO_PinInput;
GPIO_InitStructure.GPIO_Type=GPIO_Type_OpenCollector;
GPIO_InitStructure.GPIO_IPInputConnected=GPIO_IPInputConnected_Enable;
GPIO_InitStructure.GPIO_Alternate=GPIO_InputAlt1;
GPIO_Init(GPIO5,&GPIO_InitStructure);

/* P5.0 alternate output 2, CAN_TX */
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;
GPIO_InitStructure.GPIO_Direction=GPIO_PinOutput;
GPIO_InitStructure.GPIO_Type=GPIO_Type_PushPull;
GPIO_InitStructure.GPIO_IPInputConnected=GPIO_IPInputConnected_Disable;
GPIO_InitStructure.GPIO_Alternate=GPIO_OutputAlt2;
GPIO_Init(GPIO5,&GPIO_InitStructure);

}

void wait (void)  {                       /* Wait function                    */
  int d;

  d = AD_last;                            /* Read AD_last value               */
  if (d != AD_last)                       /* Make sure that AD interrupt did  */
    d = AD_last;                          /* not interfere with value reading */

  d *= 500;
  d += 50000;                             /* Scale analog value for delay     */
                                          /* lower value -> longer delay      */
  while (d--);                            /* Only to delay for LED flashes    */
}

void CAN_Com_LoopBack(void)
{
  set_cursor (0, 1);

  CAN_DeInit();
  /* initialize the CAN at a standard bitrate, interrupts disabled */
  CAN_InitStructure.CAN_ConfigParameters=CAN_CR_DAR;
  CAN_InitStructure.CAN_Bitrate=CAN_BITRATE_125K;
  CAN_Init(&CAN_InitStructure);



  /* switch into Loopback+Silent mode (self-test) */
  //CAN_EnterTestMode(CAN_TESTR_LBACK | CAN_TESTR_SILENT);
  lcd_print ("C");

  /* configure the message objects */
  CAN_SetUnusedAllMsgObj();
  CAN_SetTxMsgObj(CAN_TX_MSGOBJ, CAN_STD_ID, DISABLE);
  CAN_SetRxMsgObj(CAN_RX_MSGOBJ, CAN_STD_ID, 0, CAN_LAST_STD_ID, TRUE);
  lcd_print ("D");
  /* Send the pre-defined answer */
  if(TxCanMsg[3].Id == 0x013)
  {
  	lcd_print("OK");
    CAN_SendMessage(CAN_TX_MSGOBJ, &TxCanMsg[3]);
  }
  lcd_print ("E");
  /* wait until end of transmission */
  if(CAN_GetFlagStatus(CAN_SR_TXOK))
  	lcd_print("1");
  else
    lcd_print("0");											   

  if(CAN_GetTransmitErrorCounter() <= 1)
  	lcd_print("0");
  else
	lcd_print("1");

  CAN_WaitEndOfTx();
  lcd_print ("F");

  /* wait for reception of a data frame */
  while (!CAN_ReceiveMessage(CAN_RX_MSGOBJ, FALSE, &RxCanMsg))
  {
    /*Add Timer*/
  	wait();
  }
  lcd_print ("G");

  /* Test Received Msg */
  if((RxCanMsg.IdType == CAN_STD_ID)&&(RxCanMsg.Id == 0x321)&&(RxCanMsg.Dlc == 4)
    &&(RxCanMsg.Data[0]==0xAA)&&(RxCanMsg.Data[1]==0x55)&&(RxCanMsg.Data[2]==0xAA)&&(RxCanMsg.Data[3]==0x55)){
    /*Received Msg OK*/
    lcd_print ("A");
  } else {
    /*Received Msg KO*/
    lcd_print ("B");
  }

  /* release the message objects */
  CAN_ReleaseTxMessage(CAN_TX_MSGOBJ);
  CAN_ReleaseRxMessage(CAN_RX_MSGOBJ);

  /* switch back into Normal mode */
  //CAN_LeaveTestMode();

}


int main (void) {
  unsigned int i, n;
//  unsigned short AD_old, AD_value;

  SCU_Configuration();/*PCLK=8MHz*/

  IO_Init();

//  /* ADC Setup                                                                */
//  SCU->GPIOIN[4]  |= 0x01;                /* P4.0 input  - mode 0             */
//  SCU->GPIOOUT[4] &= 0xFFFC;              /* P4.0 output - mode 0             */
//  GPIO4->DDR      &= 0xFE;                /* P4.0 direction - input           */
//  SCU->GPIOANA    |= 0x0001;              /* P4.0 analog mode ON              */
//                                          
//  ADC->CR         |= 0x0002;              /* Set POR bit                      */
//  for (n = 0; n < 100000; n ++);          /* Wait > 1 ms  (at 96 MHz)         */
//
//  ADC->CR         &= 0xFFF7;              /* Clear STB bit                    */
//  for (n = 0; n < 1500; n ++);            /* Wait > 15 us (at 96 MHz)         */
//
//  ADC->CR         |= 0x0400;              /* Enable end of conversion interupt*/
//  ADC->CCR         = 0x0003;              /* AD Conversion, No WDG on Ch 0    */

  SCU->GPIOOUT[7]  = 0x5555;              /* P7.0..7 output - mode 1          */
  GPIO7->DDR       = 0xFF;                /* P7.0..7 Outputs (LED Data)       */

  /* LCD Setup                                                                */
  GPIO8->DDR       = 0xFF;                /* P8.0..7 Outputs (LCD Data)       */
  GPIO9->DDR       = 0x07;                /* P9.0..2 Outputs (LCD Control)    */

  lcd_init();
  lcd_clear();
  lcd_print (" MCB-STR9 DEMO  ");
  set_cursor (0, 1);
  lcd_print ("  www.keil.com  "); 

  for (i = 0; i < 200; i++) wait();       /* Wait for initial display         */

//  /* Configure and enable IRQ for A/D Converter (ADC)                         */
//  VIC0->VAiR[15]  = (unsigned int)ADC_IRQ_Handler; /* Setup ADC IRQ Hndl addr */
//  VIC0->VCiR[15] |= 0x20;                 /* Enable the vector interrupt      */
//  VIC0->VCiR[15] |= 15;                   /* Specify the interrupt number     */
//  VIC0->INTER    |= (1<<15);              /* Enable ADC interrupt             */

  /* Configure and enable IRQ for Timer (TIM3)                                */
  VIC0->VAiR[7]   = (unsigned int)TIM3_IRQ_Handler;/* Setup TIM3 IRQ Hndl addr*/
  VIC0->VCiR[7]  |= 0x20;                 /* Enable the vector interrupt      */
  VIC0->VCiR[7]  |= 7;                    /* Specify the interrupt number     */
  VIC0->INTER    |= (1<<7);               /* Enable TIM3 interrupt            */

  /* Timer 3 Configuration (TIM3)                                             */
  TIM3->CNTR      = 0x0000;               /* Setup TIM3 counter register      */
  TIM3->CR2      &= 0xFF00;               /* Clear prescaler value            */
  TIM3->CR2      |= 0x000F;               /* Setup TIM3 prescaler             */
  TIM3->CR2      |= 0x2000;               /* TIM3 timer overflow intrupt en   */
  TIM3->CR1      |= 0x8000;               /* TIM3 counter enable              */

  CAN_Com_LoopBack();
  while (1) {                             /* Loop forever                     */
    for (n = 0x01; n <= 0xFF; n <<= 1) {
      GPIO7->DR[0x3FC] = n;               /* Turn on LED                      */
      wait();                             /* Delay                            */
/*      AD_value = AD_last;               // Read AD_last value              
      if (AD_value != AD_last)            // Make sure that AD interrupt did  
        AD_value = AD_last;               // not interfere with value reading 
      AD_value /= 13;                     // Scale to AD_Value to 0 - 78      
      if (AD_old != AD_value)  {          // If AD value has changed          
        set_cursor (0, 1);
        AD_old = AD_value;
        for (i = 0; i < 16; i++)  {       // Disp bargraph according to AD    
          if (AD_value > 5)  {
            lcd_putchar (0x05);
            AD_value -= 5;
          }  else  {
            lcd_putchar (AD_value);
            AD_value = 0;
          }
        }
      }	*/
    }
  }
}