/*************************************************************************
 *
 *    Used with ICCARM and AARM.
 *
 *    (c) Copyright IAR Systems 2007
 *
 *    File name   : main.c
 *    Description : CAN test
 *
 *    History :
 *    1. Date        : April 28, 2007
 *       Author      : Stanimir Bonev
 *       Description : Create
 *
 *    $Revision: 1.4 $
 **************************************************************************/
// #include <stdio.h>

#include "stm32f10x_lib.h"
#include "arm_comm.h"
#include "lcd.h"
#include "includes.h"
#include "stm32f10x_map.h"
#include "adc.h"
#include "pwm.h"
#include "bits.h"
#include "mmc.h"
#include "test.h"
#include "rtc.h"
#include "nRF24L01.h"
#include "const.h"
#include "i2c.h"
#include "drv_lisxxx.h"

#define MENU_NUMB   9

unsigned char Inversion[] = { 0, 0, 0, 0, 0, 0, 0, 0 };

unsigned char Menu[MENU_NUMB][15] = {
 " Test MMC Card\0",
 " Test Audio   \0",
 " Test RTC     \0",
 " Test NRF     \0",
 " Test USB     \0",
 " Test Acceler.\0",
 " Test Port    \0",
 " Test UEXT    \0",
 " Test Joystick\0"
 // "              \0",
 // "              \0",
 // "www.olimex.com\0"
};

#define KEY_NONE    0
#define KEY_UP      1
#define KEY_DOWN    2
#define KEY_LEFT    3
#define KEY_RIGHT   4
#define KEY_CENTER  5

#define UP_VALUE        960
#define DOWN_VALUE      190
#define LEFT_VALUE     1990
#define RIGHT_VALUE     470
#define DIVERSION        30

// const static unsigned short SinTable[8] = {  0x07FF, 0x0DA7, 0x0FFF, 0x0DA7, 0x07FF, 0x0257, 0x0000, 0x0257 };

__root __no_init volatile CAN_TypeDef     ttt @ CAN_BASE;
__root __no_init volatile RCC_TypeDef     ttt1 @ RCC_BASE;
__root __no_init volatile GPIO_TypeDef    ttt2 @ GPIOB_BASE;
__root __no_init volatile AFIO_TypeDef    ttt3 @ AFIO_BASE;
__root __no_init volatile I2C_TypeDef     ttt4 @ I2C1_BASE;
__root __no_init volatile RTC_TypeDef     RTC_ttt @ RTC_BASE;

unsigned char ch=0, index=0, but1_flag=0, but2_flag=0, offset, menu_flag=0;
unsigned char config, status_temp, payload;
extern unsigned char status;
extern GPIO_InitTypeDef GPIO_InitStructure;
I2C_InitTypeDef I2C_InitStructure;
signed char new_pos=0, cur_pos=-1;
volatile unsigned int dly;
unsigned char JoyPos;
unsigned char MenuPos;
Int16U ADCValue;
unsigned char jjj=0;
unsigned char test_state=0;


void Delay_ (unsigned long a) { while (--a!=0); }

/*************************************************************************
 * Function Name: InitJoystick
 * Parameters: none
 * Return: none
 *
 * Description: Init joystick position
 *
 *************************************************************************/
void InitJoystick(void) {

  // Set variables asociates
  JoyPos = 0;
  MenuPos = 1;

  // Init
  ADCInit();

  // BUTTON CENTER as input
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOC, &GPIO_InitStructure);

  // B1 as input
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_13;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOC, &GPIO_InitStructure);

}


/*************************************************************************
 * Function Name: GetJoystickPosition
 * Parameters: none
 * Return: Joistick position
 *
 * Description: Measure ADC and return joystick position
 *
 *************************************************************************/
unsigned char GetJoystickPosition (void) {

  ADCValue = GetADCChanel(ADC_Channel_15);

  if( (ADCValue>(UP_VALUE-DIVERSION))&&(ADCValue<(UP_VALUE+DIVERSION)) )       { return KEY_UP; }
  if( (ADCValue>(DOWN_VALUE-DIVERSION))&&(ADCValue<(DOWN_VALUE+DIVERSION)) )   { return KEY_DOWN; }
  if( (ADCValue>(LEFT_VALUE-DIVERSION))&&(ADCValue<(LEFT_VALUE+DIVERSION)) )   { return KEY_LEFT; }
  if( (ADCValue>(RIGHT_VALUE-DIVERSION))&&(ADCValue<(RIGHT_VALUE+DIVERSION)) ) { return KEY_RIGHT; }

  if((GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_6)) == Bit_SET) return KEY_CENTER;

  return KEY_NONE;

}

/*************************************************************************
 * Function Name: Clk_Init
 * Parameters: Int32U Frequency
 * Return: Int32U
 *
 * Description: Init clock system
 *
 *************************************************************************/
void Clk_Init(void)
{
  // 1. Cloking the controller from internal HSI RC (8 MHz)
  RCC_HSICmd(ENABLE);
  // wait until the HSI is ready
  while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);
  RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);
  // 2. Enable ext. high frequency OSC
  RCC_HSEConfig(RCC_HSE_ON);
  // wait until the HSE is ready
  while(RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET);
  // 3. Init PLL
  RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9); // 72MHz
//  RCC_PLLConfig(RCC_PLLSource_HSE_Div2,RCC_PLLMul_9); // 72MHz
  RCC_PLLCmd(ENABLE);
  // wait until the PLL is ready
  while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
  // 4. Set system clock divders
  RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_1Div5);
  RCC_ADCCLKConfig(RCC_PCLK2_Div8);
  RCC_PCLK2Config(RCC_HCLK_Div1);
  RCC_PCLK1Config(RCC_HCLK_Div2);
  RCC_HCLKConfig(RCC_SYSCLK_Div1);
  /* Flash 1 wait state */
  *(vu32 *)0x40022000 = 0x01;
  // 5. Clock system from PLL
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
}

/*************************************************************************
 * Function Name: USBSettings
 * Parameters: None
 * Return: None
 *
 * Description: Initialization of USB
 *
 *************************************************************************/
void USBSettings(void) {

  // Enable GPIOC clock
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOA, ENABLE);
  //RCC_APB1PeriphResetCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOA, ENABLE);

  // Configure PC.12 as output push-pull (LED)
  GPIO_WriteBit(GPIOC,GPIO_Pin_12,Bit_SET);
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_12;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOC, &GPIO_InitStructure);

  // Configure PA.0 as input button (WAKE_UP)
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_0;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  USB_Init(1,2,UsbClassHidConfigure);
  HidInit();

  // Soft connection enable
  USB_ConnectRes(TRUE);

  // Enable interrupts
  __enable_interrupt();

}


/*************************************************************************
 * Function Name: UpdateMenu
 * Parameters: Position of menue
 * Return: None
 *
 * Description: Black mark of menu position
 *
 *************************************************************************/
void UpdateMenu(unsigned char pos) {

  Inversion[pos-1] = 1;

  if(menu_flag==0) {
		if(pos==9) { offset=3; menu_flag=1; }
    if(pos==8) { offset=2; menu_flag=1; }
    if(pos==7) { offset=1; }
    if(pos==1) { offset=0; }
  }
  else {
    if(pos==9) { offset=3; }
		if(pos==8) { offset=2; }
    if(pos==7) { offset=1; }
    if(pos==1) { offset=0;  menu_flag=0; }
  }


  LCDClear();
  LCDStr ( 0, Menu[0+offset], Inversion[0+offset]);
  LCDStr ( 1, Menu[1+offset], Inversion[1+offset]);
  LCDStr ( 2, Menu[2+offset], Inversion[2+offset]);
  LCDStr ( 3, Menu[3+offset], Inversion[3+offset]);
  LCDStr ( 4, Menu[4+offset], Inversion[4+offset]);
  LCDStr ( 5, Menu[5+offset], Inversion[5+offset]);
  LCDUpdate();

  Inversion[pos-1] = 0;
}

/*************************************************************************
 * Function Name: TestNRF
 * Parameters: none
 * Return: None
 *
 * Description: Send and receive one byte
 *
 *************************************************************************/
void TestNRF(void) {

  // BUTTON1 =================================================================
  // Check button1 pressed
  // if (((BUT1)==0) && (but1_flag==0))    {
  if (((BUT2)==Bit_SET) && (but2_flag==0))    {

    // Send one byte -> 0x45 -------------------------------------------------

    // Chip enable low
    CE_LOW();

    // Setting for TX device
    // Write CONFIG register -> 00001010 - CRC enable, power-up, TX
    status = SPI_Send_command_with_ADDR(W_REGISTER,CONFIG_REG_ADDR, 0x0A);

    // Send payload - send any data
    status = SPI_Send_command_without_ADDR(W_TX_PAYLOAD, 0x45);

    // Pulse for CE -> starts the transmission.
    CE_HIGH();
    CE_LOW();

    // Read STATUS register
    status = SPI_Send_command_without_ADDR(NOP, NOP);

    // if exceed number of transmision packets
    if ((status & MAX_RT) != 0) {

      // Clear MAX_RT bit in status register
      status_temp = SPI_Send_command_with_ADDR(W_REGISTER, STATUS_ADDR, (status|MAX_RT));

      // No communication event here
      // ....
    }

    // If packet sent on TX
    if ((status & TX_DS) != 0) {

      // Clear TX_DS bit in status register
      status_temp = SPI_Send_command_with_ADDR(W_REGISTER, STATUS_ADDR, (status|TX_DS));

      // Your code here
      // ...
    }


    // If TX full
    if ((status & TX_FULL) != 0)  {

      // Flush TX FIFO (in TX mode)
      status_temp = SPI_Send_command_without_ADDR(FLUSH_TX, NOP);

      // Your code here
      // ...
    }

    // End send one byte -> 0x45 ---------------------------------------------

    // Setting for RX device
    //Write CONFIG register -> 00001010 - CRC enable, power-up, RX
    status = SPI_Send_command_with_ADDR(W_REGISTER,CONFIG_REG_ADDR, 0x0B);

    // button was pressed - set flag
    but2_flag=1;

  }

  // Clear if button is already not pressed
  //if (((BUT1)!=0) && (but1_flag !=0)) {
  if (((BUT2)!=Bit_SET) && (but2_flag !=0)) {

    // Just simple delay
    Delay_(BUT_TIME);

    // clear button flag
    but2_flag = 0;
  }

  // Chip enable high
  CE_HIGH();

  // wait for receive signal - IRQ
  if ((IRQ)==0) {

    //Read STATUS status register
    status = SPI_Send_command_without_ADDR(NOP, NOP);

    // Set high when new data arrives RX FIFO
    if ((status & RX_DR) != 0) {

      // Chip enable low
      CE_LOW();

      //Read payload data
      payload=SPI_Send_command_without_ADDR(R_RX_PAYLOAD, NOP);

      // Clear RX_DR bit in status register
      status_temp = SPI_Send_command_with_ADDR(W_REGISTER, STATUS_ADDR, (status|RX_DR));
    }

    // Check received data
    if (payload == 0x46)  {

      // Clear data
      payload = 0;

      // LCD init
      LCDInit();
      LCDContrast(0x45);
      LCDClear();
      LCDStr ( 0, "   NRF Test   ", 0 );
      LCDStr ( 1, "  SUCCESS!!!  ", 0 );
      LCDStr ( 5, "exit          ", 0 );
      LCDUpdate();

    }
  }

}


// MMA -------------------------------------------------------------------------

#define WHO_AM_I          0x0F
#define OFFSET_X          0x16
#define OFFSET_Y          0x17
#define OFFSET_Z          0x18
#define GAIN_X            0x19
#define GAIN_Y            0x1A
#define GAIN_Z            0x1B
#define CTRL_REG1         0x20
#define CTRL_REG2         0x21
#define CTRL_REG3         0x22
#define HP_FILTER_RESET   0x23
#define STATUS_REG        0x27
#define OUTX_L            0x28
#define OUTX_H            0x29
#define OUTY_L            0x2A
#define OUTY_H            0x2B
#define OUTZ_L            0x2C
#define OUTZ_H            0x2D
#define FF_WU_CFG         0x30
#define FF_WU_SRC         0x31
#define FF_WU_ACK         0x32
#define FF_WU_THS_L       0x34
#define FF_WU_THS_H       0x35
#define FF_WU_DURATION    0x36
#define DD_CFG            0x38
#define DD_SRC            0x39
#define DD_ACK            0x3A
#define DD_THSI_L         0x3C
#define DD_THSI_H         0x3D
#define DD_THSE_L         0x3E
#define DD_THSE_H         0x3F
#define LIS_ADDRESS       0x3A

char buff_x[10];
char buff_y[10];
char buff_z[10];

unsigned char value_h;
unsigned char value_l;
unsigned int  value;
unsigned char val;



void InitMMA(void) {

   // GPIOB Periph clock enable
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

  // Configure PB5 as input - SENS_INT
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_5;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  Hrd_I2C_Init();

  // Who Am I
  ReadReg(&val, WHO_AM_I);    // have to be 0x3A

  // Set CTRL_REG1
  // WriteReg(0xC7, CTRL_REG1);
  WriteReg(0xC7, CTRL_REG1);
  //ReadReg(&val, CTRL_REG1);

  // Set CTRL_REG2