// Чтение 16 байт из AT45Dx Memory Test

//******************************************************************************
//                                                    
//             AT45DX     Slave           MSP430F169 Master
//             -----------------          -----------------
//            |                 |     /|\|              XIN|-
//            |                 |      | |                 |
//            |                 |      --|RST          XOUT|-
//            |                 |        |             P1.0|-> LED
//            |              SI |<-------|P3.1/SIMO0       |
//            |              SO |------->|P3.2/SOMI0       |
//            |             CLK |<-------|P3.3/UCLK0       |
//            |                 |        |                 |
//            |           CS#   |<-------|P5.1             |
//            |        RESET#   |<-------|P5.2             |
//
//******************************************************************************

#include  <msp430x16x.h>

#define LED_ON    (P1OUT |= BIT0)
#define LED_OFF   (P1OUT &= ~BIT0)
#define MEM_RES0            (P5OUT &= ~BIT2)    
#define MEM_RES1            (P5OUT |= BIT2)    
#define CS_0            (P5OUT &= ~BIT1)    
#define CS_1            (P5OUT |= BIT1)    

volatile char akn;
volatile char bufSOMI[32];
volatile char bufSOMICnt = 0;
volatile char readAT45D = 0;       // 1 = progress

void init_spi();
void AT45DXReset();
void AT45DXManufactureID();
void readAT45DX();


//*********************************************************
// main()
// UART0
//*********************************************************
int main(void)
{
  volatile unsigned int i;

  WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog
  P1DIR |= BIT0;                            // Установка вывода для LED output
  init_spi();
  IE1 |= URXIE0 + UTXIE0;                   // Разрешить RX и TX прерывания
  //Memory Reset
  CS_1;
  AT45DXReset();
  CS_0;
  _BIS_SR(GIE);                             // Разрешить прерывания
  while ((IFG1 & UTXIFG0) == 0);            // USART0 TX буфер готов получить новые данные?
  AT45DXManufactureID();
  while(1){
    LED_ON;
    readAT45DX();
  }    
}

#pragma vector=USART0RX_VECTOR
__interrupt void SPI0_rx (void)
{
  while ((U0TCTL&TXEPT)!= TXEPT);             // USARTo TX пустой?

  if(readAT45D == 1){                        // идёт чтение из АТ45?
    bufSOMI[bufSOMICnt] = RXBUF0;            // запись данных в буфер
    bufSOMICnt++;                           // увеличиваем счётчик
  }
  
  akn = RXBUF0;                                // подтверждение от АТ45
  
}

#pragma vector=USART0TX_VECTOR
__interrupt void SPI0_tx (void)
{
  _NOP();
  if(readAT45D == 1){                        // идёт чтение из АТ45?
    // dumn data
    TXBUF0 = 0x00;                            // выпихиваем данные из АТ45
  }

}

//*********************************************************
// инициализация SPI
//*********************************************************
void init_spi(){
  
  P3SEL |= 0x0E;                            // P3.1,2,3 SPI для SPI
  P3DIR |= BIT1;                            // P3.1 установить SIMO output
  P3DIR |= BIT3;                            // P3.3 установить CLK output
  P5DIR |= BIT1;                            // P5.1 установить CS# output
  P5DIR |= BIT2;                            // P5.2 установить Reset# output
  
  
  U0CTL = CHAR + SYNC + MM + SWRST;         // 8-bit, SPI, Master
  U0TCTL = CKPL + SSEL1 + STC;              // Полярность, SMCLK, 3-wire

  U0BR0 = 0x02;                             // SPICLK = SMCLK/2
  U0BR1 = 0x00;
  U0MCTL = 0x00;
  ME1 |= USPIE0;                            // Module enable
  U0CTL &= ~SWRST;                          // SPI enable
}
    
//*********************************************************
// Сброс АТ45
//*********************************************************
void AT45DXReset(){
  MEM_RES0;                                        // установить в 0
  for (int i = 0x7F; i > 0; i--);              // временная задержка
  MEM_RES1;                                        // установить в 1
}


//*********************************************************
// Получить идентификационный номер
//*********************************************************
void AT45DXManufactureID(){
  AT45DXReset();                                // сброс
  while ((U0TCTL&TXEPT)!= TXEPT);                // ожидание пока ТХ буфер не пуст
  TXBUF0 = 0x9F;                                // отправить комманду
  while ((U0TCTL&TXEPT)!= TXEPT);
  TXBUF0 = 0x00;
  while ((U0TCTL&TXEPT)!= TXEPT);
  TXBUF0 = 0x00;
  while ((U0TCTL&TXEPT)!= TXEPT);
  TXBUF0 = 0x00;
}


//*********************************************************
// чтение АТ45
// прочитать 16 байт из AT45DX с адреса 0 до 15
// и сохрантить их в bufSOMI[]
//*********************************************************
void readAT45DX(){

  AT45DXReset();                                // сброс

  while ((U0TCTL&TXEPT)!= TXEPT);
  bufSOMICnt = 0;                                // обнулить счётчик
  TXBUF0 = 0x03;                                // отправить комманду
  while ((U0TCTL&TXEPT)!= TXEPT);
  TXBUF0 = 0x00;                                // отправить адрес
  while ((U0TCTL&TXEPT)!= TXEPT);
  TXBUF0 = 0x00;
  while ((U0TCTL&TXEPT)!= TXEPT);
  readAT45D = 1;                                // чтение по прерыванию начинается тут.
  TXBUF0 = 0x00;
  while(bufSOMICnt<=0x0F){                        // дождаться пока 16 байт запушутся в буфер
    _NOP();
  };
  readAT45D = 0;                                // чтение по прерыванию заканчивается тут.
}

char bufSOMI[32];
volatile char bufSOMICnt = 0;

#pragma vector=USART0RX_VECTOR
__interrupt void SPI0_rx (void)
{
  volatile char bt;
  bt = RXBUF0;
  akn = bt;  
  bufSOMI[bufSOMICnt] = bt; // !!! Warning[Pa082]: undefined behavior: the order of volatile accesses is undefined in this statement
  
}

  char Tmp = bt;
  bufSOMI[bufSOMICnt] = Tmp; // !!! no Warnings

#pragma vector=USART0RX_VECTOR
__interrupt void SPI0_rx (void)
{
  char bt = RXBUF0;
  akn = bufSOMI[bufSOMICnt] = bt;
}

char F_ReadByte(char addr){   // addr=D7
  unsigned char Mask,i,d;
  P3OUT &=~ BIT0;   //Select AT
  delay(100);  //пауза
  Mask=1;
  for (i=0;i<=7;i++){
    if (Mask & addr) P3OUT |=SDI;
              else P3OUT &= ~SDI;
    P2OUT |= SCLK;
    Mask=Mask<<1;
    _NOP();
    P2OUT &= ~SCLK;
    _NOP();
    }
  Mask=1;
  d=0;
  for (i=0;i<=7;i++){
    P2OUT |= SCLK;
    _NOP();
    if (P3IN & SDO) d=d+Mask;
    Mask=Mask<<1;
    P2OUT &= ~SCLK;
    _NOP();
    }
  P3OUT |= BIT0;
  return(d);  
}