/* Two-Wire Interface 0 (0xFFC01400 - 0xFFC014FF) */

#define TWI0_CLKDIV        0xFFC01400  /* Serial Clock Divider Register                */

#define TWI0_CONTROL       0xFFC01404  /* TWI0 Master Internal Time Reference Register */

#define TWI0_SLAVE_CTRL    0xFFC01408  /* Slave Mode Control Register                  */

#define TWI0_SLAVE_STAT    0xFFC0140C  /* Slave Mode Status Register                   */

#define TWI0_SLAVE_ADDR    0xFFC01410  /* Slave Mode Address Register                  */

#define TWI0_MASTER_CTRL   0xFFC01414  /* Master Mode Control Register                 */

#define TWI0_MASTER_STAT   0xFFC01418  /* Master Mode Status Register                  */

#define TWI0_MASTER_ADDR   0xFFC0141C  /* Master Mode Address Register                 */

#define TWI0_INT_STAT      0xFFC01420  /* TWI0 Master Interrupt Register               */

#define TWI0_INT_MASK      0xFFC01424  /* TWI0 Master Interrupt Mask Register          */

#define TWI0_FIFO_CTRL     0xFFC01428  /* FIFO Control Register                        */

#define TWI0_FIFO_STAT     0xFFC0142C  /* FIFO Status Register                         */

#define TWI0_XMT_DATA8     0xFFC01480  /* FIFO Transmit Data Single Byte Register      */

#define TWI0_XMT_DATA16    0xFFC01484  /* FIFO Transmit Data Double Byte Register      */

#define TWI0_RCV_DATA8     0xFFC01488  /* FIFO Receive Data Single Byte Register       */

#define TWI0_RCV_DATA16    0xFFC0148C  /* FIFO Receive Data Double Byte Register       */

/* Two-Wire Interface 1 (0xFFC02200 - 0xFFC022FF) */

#define TWI1_CLKDIV        0xFFC02200  /* Serial Clock Divider Register                */

#define TWI1_CONTROL       0xFFC02204  /* TWI1 Master Internal Time Reference Register */

#define TWI1_SLAVE_CTRL    0xFFC02208  /* Slave Mode Control Register                  */

#define TWI1_SLAVE_STAT    0xFFC0220C  /* Slave Mode Status Register                   */

#define TWI1_SLAVE_ADDR    0xFFC02210  /* Slave Mode Address Register                  */

#define TWI1_MASTER_CTRL   0xFFC02214  /* Master Mode Control Register                 */

#define TWI1_MASTER_STAT   0xFFC02218  /* Master Mode Status Register                  */

#define TWI1_MASTER_ADDR   0xFFC0221C  /* Master Mode Address Register                 */

#define TWI1_INT_STAT      0xFFC02220  /* TWI1 Master Interrupt Register               */

#define TWI1_INT_MASK      0xFFC02224  /* TWI1 Master Interrupt Mask Register          */

#define TWI1_FIFO_CTRL     0xFFC02228  /* FIFO Control Register                        */

#define TWI1_FIFO_STAT     0xFFC0222C  /* FIFO Status Register                         */

#define TWI1_XMT_DATA8     0xFFC02280  /* FIFO Transmit Data Single Byte Register      */

#define TWI1_XMT_DATA16    0xFFC02284  /* FIFO Transmit Data Double Byte Register      */

#define TWI1_RCV_DATA8     0xFFC02288  /* FIFO Receive Data Single Byte Register       */

#define TWI1_RCV_DATA16    0xFFC0228C  /* FIFO Receive Data Double Byte Register       */

/* Two-Wire Interface 0 */

#define pTWI0_CLKDIV       ((volatile unsigned short *)TWI0_CLKDIV)

#define pTWI0_CONTROL      ((volatile unsigned short *)TWI0_CONTROL)

#define pTWI0_SLAVE_CTRL   ((volatile unsigned short *)TWI0_SLAVE_CTRL)

#define pTWI0_SLAVE_STAT   ((volatile unsigned short *)TWI0_SLAVE_STAT)

#define pTWI0_SLAVE_ADDR   ((volatile unsigned short *)TWI0_SLAVE_ADDR)

#define pTWI0_MASTER_CTRL  ((volatile unsigned short *)TWI0_MASTER_CTRL)

#define pTWI0_MASTER_STAT  ((volatile unsigned short *)TWI0_MASTER_STAT)

#define pTWI0_MASTER_ADDR  ((volatile unsigned short *)TWI0_MASTER_ADDR)

#define pTWI0_INT_STAT     ((volatile unsigned short *)TWI0_INT_STAT)

#define pTWI0_INT_MASK     ((volatile unsigned short *)TWI0_INT_MASK)

#define pTWI0_FIFO_CTRL    ((volatile unsigned short *)TWI0_FIFO_CTRL)

#define pTWI0_FIFO_STAT    ((volatile unsigned short *)TWI0_FIFO_STAT)

#define pTWI0_XMT_DATA8    ((volatile unsigned short *)TWI0_XMT_DATA8)

#define pTWI0_XMT_DATA16   ((volatile unsigned short *)TWI0_XMT_DATA16)

#define pTWI0_RCV_DATA8    ((volatile unsigned short *)TWI0_RCV_DATA8)

#define pTWI0_RCV_DATA16   ((volatile unsigned short *)TWI0_RCV_DATA16)

/* Two-Wire Interface 1 */

#define pTWI1_CLKDIV       ((volatile unsigned short *)TWI1_CLKDIV)

#define pTWI1_CONTROL      ((volatile unsigned short *)TWI1_CONTROL)

#define pTWI1_SLAVE_CTRL   ((volatile unsigned short *)TWI1_SLAVE_CTRL)

#define pTWI1_SLAVE_STAT   ((volatile unsigned short *)TWI1_SLAVE_STAT)

#define pTWI1_SLAVE_ADDR   ((volatile unsigned short *)TWI1_SLAVE_ADDR)

#define pTWI1_MASTER_CTRL  ((volatile unsigned short *)TWI1_MASTER_CTRL)

#define pTWI1_MASTER_STAT  ((volatile unsigned short *)TWI1_MASTER_STAT)

#define pTWI1_MASTER_ADDR  ((volatile unsigned short *)TWI1_MASTER_ADDR)

#define pTWI1_INT_STAT     ((volatile unsigned short *)TWI1_INT_STAT)

#define pTWI1_INT_MASK     ((volatile unsigned short *)TWI1_INT_MASK)

#define pTWI1_FIFO_CTRL    ((volatile unsigned short *)TWI1_FIFO_CTRL)

#define pTWI1_FIFO_STAT    ((volatile unsigned short *)TWI1_FIFO_STAT)

#define pTWI1_XMT_DATA8    ((volatile unsigned short *)TWI1_XMT_DATA8)

#define pTWI1_XMT_DATA16   ((volatile unsigned short *)TWI1_XMT_DATA16)

#define pTWI1_RCV_DATA8    ((volatile unsigned short *)TWI1_RCV_DATA8)

#define pTWI1_RCV_DATA16   ((volatile unsigned short *)TWI1_RCV_DATA16)

static void twi_clear_all_stat (void)
{
   /* Очищает все биты состояния */
   *pTWI0_MASTER_STAT = *pTWI0_MASTER_STAT;
   ssync();
   /* Очищает все флаги прерываний, ожидающих обработки */
   *pTWI0_INT_STAT = *pTWI0_INT_STAT;
   ssync();
   /* Сброс буферов передачи и приема */
   *pTWI0_FIFO_CTRL = ( XMTFLUSH | RCVFLUSH );
   ssync();
}

/*****************************************************************************

   Сбрасывает интерфейс TWI.

******************************************************************************/

void twi_reset(void)
{
   /* Сброс контроллера TWI */
   *pTWI0_CONTROL = TWI_RESET_VAL;
   ssync();
   twi_clear_all_stat();
}

static void twiout (u8 byte, u16 ctrl)
{
   *pTWI0_XMT_DATA8 = byte;
   ssync();
   if (ctrl)
   {
      *pTWI0_MASTER_CTRL = ctrl;
      ssync();
   }
   // Ожидание опустошения FIFO передачи:
   while (*pTWI0_FIFO_STAT != XMT_EMPTY) { ssync(); }
}

/*****************************************************************************

   Выполняет запись в режиме master без использования прерываний.

******************************************************************************/

void twi_mastermode_write(u16 memaddr, u8 *pTwiDataPointer, u16 uwCount)
{
   u8 i;
   *pTWI0_FIFO_CTRL = 0;
   *pTWI0_CONTROL = ( TWI_ENA | PRESCALE_VALUE );
   *pTWI0_CLKDIV = ( ((CLKDIV_HI) << 8) | (CLKDIV_LO) );
   // Целевой адрес устройства (7-битный адрес без бита R/~W):
   *pTWI0_MASTER_ADDR = AT24_I2C_ADDR;
   twiout(memaddr >> 8,   ((uwCount+2) << 6) | MEN);
   twiout(memaddr & 0xFF, 0);
   for ( i=0; i < uwCount; i++ )
   {
      twiout(*pTwiDataPointer, 0);
      pTwiDataPointer++; /* load the next sample into the TX FIFO */
   }
   // Ожидание завершения передачи и установки бита MCOMP:
   while ((*pTWI0_INT_STAT & MCOMP) == 0) { ssync(); }
   // Установка TWI на обслуживание следующей передачи:
   *pTWI0_INT_STAT = ( XMTSERV | MCOMP );
   delay_mks(PAGE_WRITE_MKS);
}

/*****************************************************************************

   Выполняет чтение в режиме master без использования прерываний.

******************************************************************************/

void twi_mastermode_read(u16 memaddr, u8 *pTwiDataPointer, u16 uCount)
{
   u8 i;
   *pTWI0_FIFO_CTRL = 0;
   *pTWI0_CONTROL = ( TWI_ENA | PRESCALE_VALUE );
   *pTWI0_CLKDIV = ( ((CLKDIV_HI) << 8) | (CLKDIV_LO) );
   *pTWI0_MASTER_ADDR = AT24_I2C_ADDR;
   
   *pTWI0_XMT_DATA16 = (memaddr >> 8) | ((memaddr & 0x00FF) << 8);
   // Запуск передачи, после её завершения будет выдан повторный START:
   *pTWI0_MASTER_CTRL = (2 << 6) | MEN | RSTART;
   // Ожидание опустошения FIFO передачи:
   while (*pTWI0_FIFO_STAT == XMTSTAT) { ssync(); }
   // Ожидание завершения передачи по установке бита MCOMP:
   while ((*pTWI0_INT_STAT & MCOMP) == 0) { ssync(); }
   // Сброс флагов для обслуживания следующей транзакции:
   *pTWI0_INT_STAT = XMTSERV | MCOMP;
   asm("nop;");
   asm("nop;");
   asm("nop;");
   // Запуск приема данных:
   *pTWI0_MASTER_CTRL = (uCount << 6) | MEN | MDIR;
   for (i = 0; i < uCount; i++)
   {
      // Ожидание появления данных в FIFO приема:
      while (*pTWI0_FIFO_STAT == RCV_EMPTY) { ssync(); }
      // Чтение принятых данных:
      *pTwiDataPointer++ = *pTWI0_RCV_DATA8;
      ssync();
   }
   // Ожидание завершения пприема по установке бита MCOMP:
   while ((*pTWI0_INT_STAT & MCOMP) == 0) { ssync(); }
   // Сброс флагов для обслуживания следующей транзакции:
   *pTWI0_INT_STAT = RCVSERV | MCOMP;
   asm("nop;");
   asm("nop;");
   asm("nop;");   
}

twi_reset();
twi_mastermode_read(addr, pVal, count);

twi_reset();
twi_mastermode_write(addr, pVal, count);

#pragma once

#include < services/services.h>

// Значение поля Prescale регистра TWIx_CONTROL для тактовой частоты

// шины SCK (кГц) и внутренней тактовой частоты TWI=10 МГц должно быть

// равно SCK / 10000 = 50000 / 10000 = 5. Здесь SCK равно тактовой

// частоте шины в килогерцах:

#define PRESCALE_VALUE (SCK/10000)    /* PRESCALE = 50/10 = 5 */

#define TWI_RESET_VAL 0     /* значение RESET_TWI для контроллера */

// Если определен макрос FAST_I2C, то частота шины I2C будет

// 400 кГц, если же не определен, то 100 кГц:

#define FAST_I2C

#ifdef FAST_I2C

 // Период SCL в тактах 10 МГц равен 10000 кГц / 400 кГц:

 #define SCL_PERIOD (10000/400)

#else

 // Период SCL в тактах 10 МГц равен 10000 кГц / 100 кГц:

 #define SCL_PERIOD (10000/100)

#endif

// Константы для настройки скорости SCL в регистре pTWI_CLKDIV:

#define CLKDIV_HI (SCL_PERIOD/2)    // длительность лог. 1 SCL

#define CLKDIV_LO (SCL_PERIOD/2)    // длительность лог. 0 SCL

// У процессора ADSP-BF538 два порта TWI: I2C0 и I2C1.

// Если используется I2C0, то нужно для DevNumber определить 0.

// Если используется I2C1, то нужно для DevNumber определить 1.

#define DevNumber 1

#if (DevNumber == 0)

 #define pTWI_MASTER_STAT pTWI0_MASTER_STAT

 #define pTWI_INT_STAT    pTWI0_INT_STAT

 #define pTWI_FIFO_CTRL   pTWI0_FIFO_CTRL

 #define pTWI_CONTROL     pTWI0_CONTROL

 #define pTWI_XMT_DATA8   pTWI0_XMT_DATA8

 #define pTWI_MASTER_CTRL pTWI0_MASTER_CTRL

 #define pTWI_FIFO_STAT   pTWI0_FIFO_STAT

 #define pTWI_CLKDIV      pTWI0_CLKDIV

 #define pTWI_MASTER_ADDR pTWI0_MASTER_ADDR

 #define pTWI_XMT_DATA16  pTWI0_XMT_DATA16

 #define pTWI_RCV_DATA8   pTWI0_RCV_DATA8

#elif (DevNumber == 1)

 #define pTWI_MASTER_STAT pTWI1_MASTER_STAT

 #define pTWI_INT_STAT    pTWI1_INT_STAT

 #define pTWI_FIFO_CTRL   pTWI1_FIFO_CTRL

 #define pTWI_CONTROL     pTWI1_CONTROL

 #define pTWI_XMT_DATA8   pTWI1_XMT_DATA8

 #define pTWI_MASTER_CTRL pTWI1_MASTER_CTRL

 #define pTWI_FIFO_STAT   pTWI1_FIFO_STAT

 #define pTWI_CLKDIV      pTWI1_CLKDIV

 #define pTWI_MASTER_ADDR pTWI1_MASTER_ADDR

 #define pTWI_XMT_DATA16  pTWI1_XMT_DATA16

 #define pTWI_RCV_DATA8   pTWI1_RCV_DATA8

#endif

// Коды ошибок:

typedef enum
{
   TWI_OK = 0,                      // 0
   TWI_TIMEOUT_TWIOUT,              // 1
   TWI_TIMEOUT2,                    // 2
   TWI_TIMEOUT_NACK_I2C_ADRESS,     // 3
   TWI_TIMEOUT4,                    // 4
   TWI_TIMEOUT5,                    // 5
   TWI_TIMEOUT6,                    // 6
   TWI_TIMEOUT_STOP                 // 7
}TWIstate;

extern u16 twi_master_stat;

const char *twierr_decode (TWIstate twistate);
TWIstate twiout (u8 byte);
TWIstate twi_STOP (void);
TWIstate twiin (u8 *byte);
TWIstate twi_START_write (u8 I2Caddr, u16 memaddr);
TWIstate twi_START_read (u8 I2Caddr, u16 memaddr);

/*****************************************************************************

   Подпрограммы для чтения/записи на низком уровне

   регистров TWI (без использования прерываний).

*****************************************************************************/

#include "init_platform.h"

#include "TWI.h"

#include "delay.h"

#define TWI_TIMEOUT_MS  100

u16 twi_master_stat;

const char *twierr_decode (TWIstate twistate)
{
   const char *result = "twi unknown error";
   
   switch(twistate)
   {
   case TWI_OK:
      result = "OK";
      break;
   case TWI_TIMEOUT_TWIOUT:
      result = "TWI_TIMEOUT_TWIOUT";
      break;
   case TWI_TIMEOUT2:
      result = "TWI_TIMEOUT2";
      break;
   case TWI_TIMEOUT_NACK_I2C_ADRESS:
      // Отсутствует устройство на шине, или неправильный адрес I2C:
      result = "NACK to I2C address";
      break;
   case TWI_TIMEOUT4:
      result = "TWI_TIMEOUT4";
      break;
   case TWI_TIMEOUT5:
      result = "TWI_TIMEOUT5";
      break;
   case TWI_TIMEOUT6:
      result = "TWI_TIMEOUT6";
      break;
   case TWI_TIMEOUT_STOP:
      result = "TWI_TIMEOUT_STOP";
      break;
   }
   return result;
}

static void twi_clear_all_stat (void)
{
   /* Очищает все биты состояния */
   //*pTWI_MASTER_STAT = ( BUFWRERR | BUFRDERR | DNAK | ANAK | LOSTARB);
   *pTWI_MASTER_STAT = *pTWI_MASTER_STAT;
   ssync();
   /* Очищает все флаги прерываний, ожидающих обработки */
   *pTWI_INT_STAT = *pTWI_INT_STAT;
   ssync();
   /* Сброс буферов передачи и приема */
   *pTWI_FIFO_CTRL = ( XMTFLUSH | RCVFLUSH );
   ssync();
}

/*****************************************************************************

   Сбрасывает интерфейс TWI.

******************************************************************************/

static void twi_reset(void)
{
   /* Сброс контроллера TWI */
   *pTWI_CONTROL = TWI_RESET_VAL;
   ssync();
   twi_clear_all_stat();
}

TWIstate twiout (u8 byte)
{
   TWIstate twiresult = TWI_OK;
   clock_t end_tick;
   
   *pTWI_XMT_DATA8 = byte;
   end_tick = clock() + TWI_TIMEOUT_MS * MS_TICKS;
   // Ожидание опустошения FIFO передачи:
   while (*pTWI_FIFO_STAT != XMT_EMPTY)
   {
      ssync();
      if (end_tick < clock())
      {
         twiresult = TWI_TIMEOUT_TWIOUT;
         twi_master_stat = *pTWI_MASTER_STAT;
         break;
      }
   }
   return twiresult;
}

TWIstate twi_STOP (void)
{
   TWIstate twiresult = TWI_OK;
   clock_t end_tick;
   
   // Выдача сигнала STOP:
   *pTWI_MASTER_CTRL = MEN | MDIR | STOP;
   end_tick = clock() + TWI_TIMEOUT_MS * MS_TICKS;
   // Ожидание освобождения шины после сигнала STOP:
   while (*pTWI_MASTER_STAT & BUSBUSY)
   {
      ssync();
      if (end_tick < clock())
      {
         twiresult = TWI_TIMEOUT_STOP;
         twi_master_stat = *pTWI_MASTER_STAT;
         return twiresult;
      }
   }
   return twiresult;
}

TWIstate twiin (u8 *byte)
{
   TWIstate twiresult = TWI_OK;
   clock_t end_tick;
         
   end_tick = clock() + TWI_TIMEOUT_MS * MS_TICKS;
   // Ожидание появления данных в FIFO приема:
   while (*pTWI_FIFO_STAT == RCV_EMPTY)
   {
      ssync();
      if (end_tick < clock())
      {
         twiresult = TWI_TIMEOUT5;
         twi_master_stat = *pTWI_MASTER_STAT;
         twi_STOP();
         return twiresult;
      }
   }
   // Чтение принятых данных:
   *byte = *pTWI_RCV_DATA8;
   ssync();
   return twiresult;
}

TWIstate twi_START_write (u8 I2Caddr, u16 memaddr)
{
   TWIstate twiresult = TWI_OK;
   clock_t end_tick;
   
   twi_reset();
   *pTWI_FIFO_CTRL = 0;  // очистка бит вручную
   *pTWI_CONTROL = ( TWI_ENA | PRESCALE_VALUE );
   *pTWI_CLKDIV = ( ((CLKDIV_HI) << 8) | (CLKDIV_LO) );
   // Целевой адрес устройства (7-битный адрес без бита R/~W):
   *pTWI_MASTER_ADDR = I2Caddr;
   *pTWI_XMT_DATA16 = (memaddr << 8) | ((memaddr & 0xFF00) >> 8);
   // Запуск передачи, адреса I2C и 2 байт адреса памяти FLASH,
   // сначала старший байт, потом младший. В счетчик байт
   // загружается 255, что означает бесконечную передачу,
   // пока осуществляется запись в *pTWI_XMT_DATA8:
   *pTWI_MASTER_CTRL = (255 << 6) | MEN | RSTART;
   
   twiresult = TWI_OK;
   end_tick = clock() + TWI_TIMEOUT_MS * MS_TICKS;
   // Ожидание опустошения FIFO передачи:
   while (*pTWI_FIFO_STAT == XMTSTAT)
   {
      ssync();
      if (end_tick < clock())
      {
         // Устройство не ответило на адрес I2C.
         // Либо его нет, либо неправильный адрес.
         twiresult = TWI_TIMEOUT_NACK_I2C_ADRESS;
         twi_master_stat = *pTWI_MASTER_STAT;
         break;
      }
   }
   return twiresult;
}

TWIstate twi_START_read (u8 I2Caddr, u16 memaddr)
{
   TWIstate twiresult = TWI_OK;
   clock_t end_tick;
   twi_reset();
   *pTWI_FIFO_CTRL = 0;  // очистка бит вручную
   *pTWI_CONTROL = ( TWI_ENA | PRESCALE_VALUE );
   *pTWI_CLKDIV = ( ((CLKDIV_HI) << 8) | (CLKDIV_LO) );
   // Целевой адрес устройства (7-битный адрес без бита R/~W):
   *pTWI_MASTER_ADDR = I2Caddr;
   *pTWI_XMT_DATA16 = (memaddr << 8) | ((memaddr & 0xFF00) >> 8);
   // Запуск передачи, адреса I2C и 2 байт адреса памяти FLASH,
   // сначала старший байт, потом младший. В счетчик байт
   // загружается 255, что означает бесконечную передачу,
   // пока осуществляется запись в *pTWI_XMT_DATA8:
   *pTWI_MASTER_CTRL = (2 << 6) | MEN | RSTART;
   
   twiresult = TWI_OK;
   end_tick = clock() + TWI_TIMEOUT_MS * MS_TICKS;
   // Ожидание опустошения FIFO передачи:
   //while (*pTWI_FIFO_STAT == XMTSTAT)
   while ((*pTWI_INT_STAT & MCOMP) == 0)
   {
      ssync();
      if (end_tick < clock())
      {
         // Устройство не ответило на адрес I2C.
         // Либо его нет, либо неправильный адрес.
         twiresult = TWI_TIMEOUT_NACK_I2C_ADRESS;
         twi_master_stat = *pTWI_MASTER_STAT;
         break;
      }
   }
   return twiresult;
}

#pragma once

#include "TWI.h"

// I2C-адрес микросхемы EEPROM FM24W256-GTR (A2A1A0 = 110):

#define FM24W256_I2C_ADDR  0x56

// Размер памяти микросхемы EEPROM FM24W256-GTR, байт:

#define FM24W256_SIZE      0x8000

// I2Caddr: адрес I2C микросхемы

// memaddr: адрес байта внутри микросхемы (0 .. 32767)

// buffdata: указатель на буфер, откуда берутся записываемые данные

// uCount: количество записываемых данных
TWIstate twi_mastermode_write(u8 I2Caddr, u16 memaddr, u8 *buffdata, u16 uCount);

// I2Caddr: адрес I2C микросхемы

// memaddr: адрес начального байта внутри микросхемы (0 .. 32767)

// buffdata: указатель на буфер, куда будут прочитаны данные

// uCount: количество считываемых данных
TWIstate twi_mastermode_read(u8 I2Caddr, u16 memaddr, u8 *buffdata, u16 uCount);

/*****************************************************************************

   Выполняет запись в микросхему FM24W256 в режиме master

   без использования прерываний.

******************************************************************************/
TWIstate twi_mastermode_write(u8 I2Caddr, u16 memaddr, u8 *buffdata, u16 uCount)
{
   u16 i;
   TWIstate twiresult;
   clock_t end_tick;
   twiresult = twi_START_write (I2Caddr, memaddr);
   if (TWI_OK == twiresult)
   {
      // Цикл передачи данных:
      for ( i=0; i < uCount; i++ )
      {
         twiresult = twiout(*buffdata++);
         if (TWI_OK != twiresult)
         {
            twi_STOP();
            return twiresult;
         }
      }
   }
   twiresult = twi_STOP();
   return twiresult;
}

/*****************************************************************************

   Выполняет чтение из микросхемы FM24W256 в режиме master

   без использования прерываний.

******************************************************************************/
TWIstate twi_mastermode_read(u8 I2Caddr, u16 memaddr, u8 *buffdata, u16 uCount)
{
   u16 i;
   TWIstate twiresult;
   clock_t end_tick;
   // Запуск передачи START, адреса I2C, R/W=0, старший байт адреса
   // FLASH, младший байт адреса FLASH:
   twiresult = twi_START_read (I2Caddr, memaddr);
   if (TWI_OK == twiresult)
   {
      // Сброс флагов для обслуживания следующей транзакции:
      *pTWI_INT_STAT = XMTSERV | MCOMP;
      // Выдача повторного START, запуск приема данных:
      *pTWI_MASTER_CTRL = (255 << 6) | MEN | MDIR | RSTART;
      for (i = 0; i < uCount; i++)
      {
         // Перед приемом последнего байта заказываем выдачу STOP:
         if (i == (uCount-1))
         {
            twiresult = twi_STOP();
            if (twiresult != TWI_OK)
               return twiresult;
         }
         twiresult = twiin(buffdata++);
         if (TWI_OK != twiresult)
         {
            twi_STOP();
            break;
         }
      }
   }
   return twiresult;
}

#include < stdio.h>

#include "FM24W256.h"

u32 address;
TWIstate twistate;

// Пример записи данных:
twistate = twi_mastermode_write(FM24W256_I2C_ADDR,
                                0,
                                (u8*)0x20000000,
                                FM24W256_SIZE);

if (TWI_OK != twistate)
{
   print("error %s, TWI_MASTER_STAT: %04X\n",
         twierr_decode(twistate), twi_master_stat);
}

// Пример чтения данных:
twistate = twi_mastermode_read(FM24W256_I2C_ADDR,
                               0,
                               (u8*)SDRAM_BUF_BEGIN,
                               FM24W256_SIZE);

if (TWI_OK != twistate)
{
   print("error %s, TWI_MASTER_STAT: %04X\n",
         twierr_decode(twistate), twi_master_stat);
}

#pragma once

#include < services/services.h>

// Значение поля Prescale регистра TWIx_CONTROL для тактовой частоты

// шины SCK (кГц) и внутренней тактовой частоты TWI=10 МГц должно быть

// равно SCK / 10000 = 50000 / 10000 = 5. Здесь SCK равно тактовой

// частоте шины в килогерцах:

#define PRESCALE_VALUE (SCK/10000)    /* PRESCALE = 50/10 = 5 */

#define TWI_RESET_VAL 0     /* значение RESET_TWI для контроллера */

// Если определен макрос FAST_I2C, то частота шины I2C будет

// 400 кГц, если же не определен, то 100 кГц:

#define FAST_I2C

#ifdef FAST_I2C

 // Период SCL в тактах 10 МГц равен 10000 кГц / 400 кГц:

 #define SCL_PERIOD (10000/400)

#else

 // Период SCL в тактах 10 МГц равен 10000 кГц / 100 кГц:

 #define SCL_PERIOD (10000/100)

#endif

// Константы для настройки скорости SCL в регистре pTWI_CLKDIV:

#define CLKDIV_HI (SCL_PERIOD/2)    // длительность лог. 1 SCL

#define CLKDIV_LO (SCL_PERIOD/2)    // длительность лог. 0 SCL

// У процессора ADSP-BF538 два порта TWI: I2C0 и I2C1.

// Если используется I2C0, то нужно для DevNumber определить 0.

// Если используется I2C1, то нужно для DevNumber определить 1.

#define DevNumber 1

#if (DevNumber==0)

 #define pTWI_MASTER_STAT   pTWI0_MASTER_STAT

 #define pTWI_INT_STAT      pTWI0_INT_STAT

 #define pTWI_FIFO_CTRL     pTWI0_FIFO_CTRL

 #define pTWI_CONTROL       pTWI0_CONTROL

 #define pTWI_XMT_DATA8     pTWI0_XMT_DATA8

 #define pTWI_XMT_DATA16    pTWI0_XMT_DATA16

 #define pTWI_MASTER_CTRL   pTWI0_MASTER_CTRL

 #define pTWI_FIFO_STAT     pTWI0_FIFO_STAT

 #define pTWI_CLKDIV        pTWI0_CLKDIV

 #define pTWI_MASTER_ADDR   pTWI0_MASTER_ADDR

#elif (DevNumber==1)

 #define pTWI_MASTER_STAT   pTWI1_MASTER_STAT

 #define pTWI_INT_STAT      pTWI1_INT_STAT

 #define pTWI_FIFO_CTRL     pTWI1_FIFO_CTRL

 #define pTWI_CONTROL       pTWI1_CONTROL

 #define pTWI_XMT_DATA8     pTWI1_XMT_DATA8

 #define pTWI_XMT_DATA16    pTWI1_XMT_DATA16

 #define pTWI_MASTER_CTRL   pTWI1_MASTER_CTRL

 #define pTWI_FIFO_STAT     pTWI1_FIFO_STAT

 #define pTWI_CLKDIV        pTWI1_CLKDIV

 #define pTWI_MASTER_ADDR   pTWI1_MASTER_ADDR

#else

 #error "BAD TWI device (DevNumber)"

#endif

void twi_reset(void);

/****************************************************

   Подпрограммы для работы с TWI на низком уровне.

*****************************************************/

#include "init_platform.h"

#include "TWI.h"

static void twi_clear_all_stat (void)
{
   /* Очищает все биты состояния */
   *pTWI_MASTER_STAT = *pTWI_MASTER_STAT;
   ssync();

   /* Очищает все флаги прерываний, ожидающих обработки */
   *pTWI_INT_STAT = *pTWI_INT_STAT;
   ssync();

   /* Сброс буферов передачи и приема */
   *pTWI_FIFO_CTRL = ( XMTFLUSH | RCVFLUSH );
   ssync();
}

// Процедура сбрасывает интерфейс TWI.

void twi_reset(void)
{
   /* Сброс контроллера TWI */
   *pTWI_CONTROL = TWI_RESET_VAL;
   ssync();
   twi_clear_all_stat();
}

#pragma once

#include "settings.h"

// Константы для настройки частоты прерываний таймера:

#define T0PERIOD (SCK/(SAMPLERATE/1000))

#define T0WIDTH  (T0PERIOD >> 1)

// Идентификатор периферии таймера для привязки прерывания:

#define TIMER0_PERIPH_INT_ID 16

extern u8 ampl256;

extern u16 voltage;

void Timer0init (void);

#include < sys/exception.h>

#include "pins.h"

#include "timer.h"

#include "TWI.h"

#include "AD5667.h"

u8 ampl256 = MAX;

u16 voltage = 600;

static void Timer0stop (void)
{
   // Запрет работы таймера:
   *pTIMER_DISABLE = TIMEN0;
   // Передача завершающей выборки с генерацией STOP:
   *pTWI_MASTER_CTRL = (2 << 6) | MEN;
   u16 val16 = SHIFT;
   *pTWI_XMT_DATA16 = (val16 >> 8)|(val16 << 8);
   // Ожидание завершения передачи I2C:
   *pTWI_INT_STAT = *pTWI_INT_STAT;
   while (0==(*pTWI_INT_STAT & MCOMP)) { ssync(); }
   twistate = TWI_IDLE;
}

// Обработчик прерывания таймера 0, который срабатывает

// с частотой 20 кГц (зависит от SAMPLERATE). При каждом

// срабатывании прерывания таймера в ЦАП AD5667R передается

// одна 16-битная выборка данных. При частоте тактов I2C

// 400 кГц масксимальная частота прерываний таймера

// ограничена 20 кГц.
EX_INTERRUPT_HANDLER(Timer0ISR)
{
   *pTIMER_STATUS = TIMIL0;
   // Счетчик фазы:
   static float phase = 0;
   // Указатель на таблицу синуса в SDRAM:
   s16 *ptr = 0;
   u16 val16phase;
   u16 val16;

   switch (twistate)
   {
   case TWI_IDLE:
      break;
   case TWI_RUNNING:
      LED(1);
      // Запись одной выборки:
      val16phase = (u16)phase;
      val16 = SHIFT + (ptr[val16phase] * (float)ampl256/600)*voltage;
      *pTWI_XMT_DATA16 = (val16 >> 8)|(val16 << 8);
      // Инкремент фазы для 375 Гц:
      phase += SINUS_TABLE_SIZE/((float)SAMPLERATE/375);
      if (phase > SINUS_TABLE_SIZE)
         phase = phase - SINUS_TABLE_SIZE;
      LED(0);
      break;
   case TWI_STOP:
      Timer0stop();
      break;
   }
}

void Timer0init (void)
{
   // Настройка таймера на частоту 20 кГц:
   *pTIMER0_PERIOD = T0PERIOD;
   *pTIMER0_WIDTH  = T0WIDTH;
   *pTIMER0_CONFIG = PWM_OUT | PULSE_HI | PERIOD_CNT | IRQ_ENA;
   // Привязка периферии к IVG:
   *pSIC_IAR2 |= PX_IVG(TIMER0_PERIPH_INT_ID, ik_ivg7);
   // Регистрация обработчика прерывания:
   register_handler_ex(ik_ivg7, Timer0ISR, EX_INT_ENABLE);
   // Установка маски прерываний:
   *pSIC_IMASK0 |= TIMER0_IRQ;
   // Разрешение работы таймера:
   *pTIMER_ENABLE = TIMEN0;
}

#pragma once

#include < services_types.h>

#include "settings.h"

// I2C-адрес без бита R/W:

#define AD5667_I2C_ADDR 0x0F

// Запись только во входной регистр:

#define CMD_WRITE_NO_UPDATE         (0 << 3)

// Обновить DAC данными входного регистра:

#define CMD_UPDATE                  (1 << 3)

// Записать в выбранный регистр, и сразу обновить весь DAC:

#define CMD_WRITE_N_AND_UPDATE_ALL  (2 << 3)

// Записать и обновить канал n DAC:

#define CMD_WRITE_AND_UPDATE_CHNL   (3 << 3)

// Команда управления питанием:

#define CMD_POWER                   (4 << 3)

// Команда программного сброса:

#define CMD_RESET                   (5 << 3)

// Команда настройки регистра LDAC:

#define CMD_LDAC_SETUP              (6 << 3)

// Команда включения/выключения внутреннего источника опорного напряжения:

#define CMD_REFERENCE               (7 << 3)

#define DAC_A     0

#define DAC_B     1

#define DAC_BOTH  7

#define S_MULTIBYTE                 (1 << 6)

// Значения, записываемые в счетчик передаваемых байт,

// чтобы генерировался или не генерировался сигнал STOP:

#define GENERATE_STOP 3

#define WITHOUT_STOP 0xFF

// Значения для управления источником опорного напряжения:

#define REF_EXTERNAL    0

#define REF_INTERNAL    1

// Состояния обработчика прерывания таймера для

// переменной twistate:

#define TWI_IDLE        0     // выборки не передаются

#define TWI_RUNNING     1     // выборки передаются

#define TWI_STOP        2     // нужна остановка с выдачей STOP в I2C/TWI

extern volatile u8 twistate;

extern u8 channelDAC;

void DAC_init (void);

void DAC_write_value (u16 data);

void DAC_set_reference (u8 ref);

void DAC_softreset (void);

void DAC_multiple_start (void);

void DAC_multiple_stop (void);

void DAC_set_channel (u8 channel);

#include "AD5667.h"

#include "TWI.h"

#include "timer.h"

// Подпрограммы для управления ЦАП AD5667. Реализованы только

// функции записи. Каждая функция (кроме DAC_multiple_start

// и DAC_multiple_stop) осуществляет одиночную запись

// по следующему алгоритму:

//    Отправка сигнала START

//    Передача 7-битного адреса и бита W

//    Передача байта команды

//    Передача 2 байт данных

//    Отправка сигнала STOP.

volatile u8 twistate = TWI_IDLE;
u8 channelDAC = DAC_A;

static inline void START (u8 stop_or_not)
{
   // Очистка бит вручную:
   *pTWI_FIFO_CTRL = 0;
   // Настройка скорости:
   *pTWI_CONTROL = ( TWI_ENA | PRESCALE_VALUE );
   // CLKDIV = (1/SCL)/(1/10MHz):
   *pTWI_CLKDIV = ( ((CLKDIV_HI) << 8) | (CLKDIV_LO) );
   // Целевой адрес устройства (7-битный адрес без бита R/~W):
   *pTWI_MASTER_ADDR = AD5667_I2C_ADDR;
   // Если stop_or_not == 0xFF, то генерации STOP по завершению
   // передачи не будет:
   *pTWI_MASTER_CTRL = (stop_or_not << 6) | MEN;
   ssync();
}

void DAC_init (void)
{
   // Сброс железа I2C:
   //twi_reset();
}

// Записывает слово в регистр данных (0 .. 65535), чтобы

// на выходе ЦАП появилось соответствующее напряжение.

void DAC_write_value (u16 data)
{
   if (TWI_IDLE == twistate)
   {
      twi_reset();
      // После передачи адреса и 3 байт будет сгенерирован STOP:
      START(GENERATE_STOP);
      // Передача команды и номера канала:
      *pTWI_XMT_DATA8 = CMD_WRITE_AND_UPDATE_CHNL | channelDAC;
      ssync();
      // Передача данных выборки:
      while (*pTWI_FIFO_STAT != XMT_EMPTY) { ssync(); }
      *pTWI_XMT_DATA16 = (data << 8) | (data >> 8);
      ssync();
      // Ожидание окончания передачи:
      *pTWI_INT_STAT = *pTWI_INT_STAT;
      while (0==(*pTWI_INT_STAT & MCOMP)) { ssync(); }
   }
}

// Устанавливает либо внутреннее, либо внешнее

// опорное напряжение ЦАП. По умолчанию, после

// включения питания, используется внешний источник

// опорного напряжения.

void DAC_set_reference (u8 ref)
{
   if (TWI_IDLE == twistate)
   {
      twi_reset();
      START(GENERATE_STOP);
      // Передача команды установки источника опорного напряжения:
      *pTWI_XMT_DATA8 = CMD_REFERENCE;
      ssync();
      while (*pTWI_FIFO_STAT != XMT_EMPTY) { ssync(); }
      // Передача настройки внутренний/внешний источник опоры:
      *pTWI_XMT_DATA16 = ref << 8;
      ssync();
      // Ожидание окончания передачи:
      *pTWI_INT_STAT = *pTWI_INT_STAT;
      while (0==(*pTWI_INT_STAT & MCOMP)) { ssync(); }
   }
}

void DAC_softreset (void)
{
   // Остановка многословной передачи, если она активна:
   DAC_multiple_stop();
   twi_reset();
   START(GENERATE_STOP);
   // Передача команды сброса:
   *pTWI_XMT_DATA8 = CMD_RESET;
   ssync();
   while (*pTWI_FIFO_STAT != XMT_EMPTY) { ssync(); }
   // Передача данных, которые ничего не значат:
   *pTWI_XMT_DATA16 = 0;
   ssync();
   // Ожидание окончания передачи:
   *pTWI_INT_STAT = *pTWI_INT_STAT;
   while (0==(*pTWI_INT_STAT & MCOMP)) { ssync(); }
}

void DAC_multiple_start (void)
{
   if (TWI_IDLE == twistate)
   {
      // Запись на выход ЦАП среднего значения:
      DAC_write_value(SHIFT);
      // Подача команды Multiple Block Write, после которой
      // каждая 16-битная выборка передается двумя байтами
      // бесконечно в цикле, без генерации STOP:
      START(WITHOUT_STOP);
      *pTWI_XMT_DATA8 = S_MULTIBYTE | CMD_WRITE_AND_UPDATE_CHNL | channelDAC;
      ssync();
      // Ожидание опустошения FIFO передачи:
      while (*pTWI_FIFO_STAT != XMT_EMPTY) { ssync(); }
      twistate = TWI_RUNNING;
      // Запуск прерываний таймера:
      Timer0init();
   }
}

void DAC_multiple_stop (void)
{
   if (TWI_RUNNING == twistate)
   {
      // Переключение конечного автомата таймера
      // на остановку:
      twistate = TWI_STOP;
      // Ожидание остановки таймера:
      while (twistate != TWI_IDLE){}
   }
}

// Установка текущего канала ЦАП, A или B.

void DAC_set_channel (u8 channel)
{
   if (TWI_RUNNING == twistate)
   {
      // Если таймер находится в режиме многобайтной
      // передачи, то требуется его остановка.
      DAC_multiple_stop();
      channelDAC = channel;
      
      DAC_multiple_start();
   }
   else
      channelDAC = channel;
}

/*****************************************************************************

 * TestAD5667, проект проверяет 16-битный ЦАП AD5667R с интерфейсом I2C.

 * Процессор ADSP-BF538. Инициализируются 32 мегабайта SDRAM на микросхеме

 * памяти MT48LC16M16A2.

 *

 * На выходе канала A (ножка 1) ЦАП AD5667R формируется синусоидальный сигнал

 * с частотой приблизительно 375 Гц.

 *****************************************************************************/

#include < math.h>

#include < math_const.h>

#include "Initialize.h"

#include "pins.h"

#include "UARTconsole.h"

#include "delay.h"

#include "umsg.h"

#include "initsdram.h"

#include "TWI.h"

#include "timer.h"

#include "AD5667.h"

static void GenSinusTable (void)
{
   s16* ptr = 0;
   int i;
   float phase = 0;
   
   for (i=0; i < SINUS_TABLE_SIZE; i++)
   {
      ptr[i] = 255 * sinf(phase);
      phase += (2*PI)/SINUS_TABLE_SIZE;
   }
}

static void ChangeAmplitude (void)
{
   static bool increment = true;
   if (increment)
   {
      if(MAX == ampl256)
         increment = false;
      else
         ampl256++;
   }
   else
   {
      if(0 == ampl256)
         increment = true;
      else
         ampl256--;
   }
}

void main (void)
{
   // Инициализация ядра и тактовых частот:
   Initialize();
   // Конфигурирование GPIO входов и выходов:
   ConfigureInputs();
   ConfigureOutputs();
   // Инициализация UART на 115200 бод (для отладки):
   InitUARTdebug();
   umsg("Тест AD5667 с передачей по I2C выборок 20 кГц,\n");
   umsg("генерируется синусодида 375 Гц с плавно меняющейся\n");
   umsg("амплитудой.\n\n");
   umsg("Для подсказки по командам введите ? или help+Enter.\n\n");
   UARTconsolePoll();
   // Инициализация 32 мегабайт SDRAM:
   InitSDRAM();
   // Создание таблицы синуса в SDRAM:
   GenSinusTable();
   // Запуск ЦАП AD5667R:
   DAC_init();
   DAC_set_reference(REF_EXTERNAL);
   DAC_multiple_start();
   // Главный цикл ничего не делает, только меняет амплитуду ampl256
   // от 0 до 255 и обратно. Эта амплитуда используется для регулирования
   // синуса, данные которого посылаются в ЦАП AD5667R в обработчике
   // прерываний EX_INTERRUPT_HANDLER(Timer0ISR).
   while(true)
   {
      delay_ms(10);
      ChangeAmplitude();
      UARTconsolePoll();
   }
}