FAT library for TMS320F28035

//###########################################################################
// FILE:   sd_card.c
// TITLE:  Example program for reading files from an SD card.
//###########################################################################
// $TI Release: F28M35x Driver Library vBeta1 $
// $Release Date: August 31, 2011 $
//###########################################################################

#include <string.h>
#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "inc/hw_nvic.h"
#include "inc/hw_sysctl.h"
#include "inc/hw_types.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/sysctl.h"
#include "driverlib/systick.h"
#include "utils/cmdline.h"
#include "utils/uartstdio.h"
#include "utils/ustdlib.h"
#include "third_party/fatfs/src/ff.h"
#include "third_party/fatfs/src/diskio.h"

//*****************************************************************************
//! \addtogroup master_example_list
//! <h1>SD card using FAT file system (sd_card)</h1>
//!
//! This example application demonstrates reading a file system from
//! an SD card.  It makes use of FatFs, a FAT file system driver.
//!
//! For additional details about FatFs, see the following site:
//! http://elm-chan.org/fsw/ff/00index_e.html
//!
//! The application may be operated via a serial terminal attached to
//! UART0. The RS232 communication parameters should be set to 115,200 bits
//! per second, and 8-n-1 mode.  When the program is started a message will be
//! printed to the terminal.  Type ``help'' for command help.
//*****************************************************************************

extern void UARTStdioIntHandler(void);

//*****************************************************************************
// Defines the size of the buffers that hold the path, or temporary
// data from the SD card.  There are two buffers allocated of this size.
// The buffer size must be large enough to hold the longest expected
// full path name, including the file name, and a trailing null character.
//*****************************************************************************
#define PATH_BUF_SIZE   80

//*****************************************************************************
// Defines the size of the buffer that holds the command line.
//*****************************************************************************
#define CMD_BUF_SIZE    64

//*****************************************************************************
// This buffer holds the full path to the current working directory.
// Initially it is root ("/").
//*****************************************************************************
static char g_cCwdBuf[PATH_BUF_SIZE] = "/";

//*****************************************************************************
// A temporary data buffer used when manipulating file paths, or reading data
// from the SD card.
//*****************************************************************************
static char g_cTmpBuf[PATH_BUF_SIZE];

//*****************************************************************************
// The buffer that holds the command line.
//*****************************************************************************
static char g_cCmdBuf[CMD_BUF_SIZE];

//*****************************************************************************
// The following are data structures used by FatFs.
//*****************************************************************************
static FATFS g_sFatFs;
static DIR g_sDirObject;
static FILINFO g_sFileInfo;
static FIL g_sFileObject;

//*****************************************************************************
// A structure that holds a mapping between an FRESULT numerical code,
// and a string represenation.  FRESULT codes are returned from the FatFs
// FAT file system driver.
//*****************************************************************************
typedef struct
{
    FRESULT fresult;
    char *pcResultStr;
}
tFresultString;

//*****************************************************************************
// A macro to make it easy to add result codes to the table.
//*****************************************************************************
#define FRESULT_ENTRY(f)        { (f), (# f) }

//*****************************************************************************
// A table that holds a mapping between the numerical FRESULT code and
// it's name as a string.  This is used for looking up error codes for
// printing to the console.
//*****************************************************************************
tFresultString g_sFresultStrings[] =
{
    FRESULT_ENTRY(FR_OK),
    FRESULT_ENTRY(FR_NOT_READY),
    FRESULT_ENTRY(FR_NO_FILE),
    FRESULT_ENTRY(FR_NO_PATH),
    FRESULT_ENTRY(FR_INVALID_NAME),
    FRESULT_ENTRY(FR_INVALID_DRIVE),
    FRESULT_ENTRY(FR_DENIED),
    FRESULT_ENTRY(FR_EXIST),
    FRESULT_ENTRY(FR_RW_ERROR),
    FRESULT_ENTRY(FR_WRITE_PROTECTED),
    FRESULT_ENTRY(FR_NOT_ENABLED),
    FRESULT_ENTRY(FR_NO_FILESYSTEM),
    FRESULT_ENTRY(FR_INVALID_OBJECT),
    FRESULT_ENTRY(FR_MKFS_ABORTED)
};

//*****************************************************************************
// Error reasons returned by ChangeDirectory().
//*****************************************************************************
#define NAME_TOO_LONG_ERROR 1
#define OPENDIR_ERROR       2

//*****************************************************************************
// A macro that holds the number of result codes.
//*****************************************************************************
#define NUM_FRESULT_CODES (sizeof(g_sFresultStrings) / sizeof(tFresultString))

//*****************************************************************************
// The number of SysTick ticks per second.
//*****************************************************************************
#define TICKS_PER_SECOND 100

//*****************************************************************************
// Storage for the filename listbox widget string table.
//*****************************************************************************
#define NUM_LIST_STRINGS 48
const char *g_ppcDirListStrings[NUM_LIST_STRINGS];

//*****************************************************************************
// Storage for the names of the files in the current directory.  Filenames
// are stored in format "(D) filename.ext" for directories or "(F) filename.ext"
// for files.
//*****************************************************************************
#define MAX_FILENAME_STRING_LEN (4 + 8 + 1 + 3 + 1)
char g_pcFilenames[NUM_LIST_STRINGS][MAX_FILENAME_STRING_LEN];

//*****************************************************************************
// Storage for the strings which appear in the status box at the bottom of the
// display.
//****************************************************************************
#define NUM_STATUS_STRINGS 6
#define MAX_STATUS_STRING_LEN (36 + 1)
char g_pcStatus[NUM_STATUS_STRINGS][MAX_STATUS_STRING_LEN];

//*****************************************************************************
// Storage for the status listbox widget string table.
//*****************************************************************************
const char *g_ppcStatusStrings[NUM_STATUS_STRINGS] =
{
    g_pcStatus[0],
    g_pcStatus[1],
    g_pcStatus[2],
    g_pcStatus[3],
    g_pcStatus[4],
    g_pcStatus[5]
};
unsigned long g_ulStatusStringIndex = 0;

//*****************************************************************************
// Forward declarations for functions called by the widgets used in the user
// interface.
//*****************************************************************************
static FRESULT ChangeToDirectory(char *pcDirectory, unsigned long *pulReason);
static const char *StringFromFresult(FRESULT fresult);

//*****************************************************************************
// This function returns a string representation of an error code
// that was returned from a function call to FatFs.  It can be used
// for printing human readable error messages.
//*****************************************************************************
static const char *
StringFromFresult(FRESULT fresult)
{
    unsigned int uIdx;

    // Enter a loop to search the error code table for a matching
    // error code.
    for(uIdx = 0; uIdx < NUM_FRESULT_CODES; uIdx++)
    {
        // If a match is found, then return the string name of the
        // error code.
        if(g_sFresultStrings[uIdx].fresult == fresult)
        {
            return(g_sFresultStrings[uIdx].pcResultStr);
        }
    }

    // At this point no matching code was found, so return a
    // string indicating unknown error.
    return("UNKNOWN ERROR CODE");
}

//*****************************************************************************
// This is the handler for this SysTick interrupt.  FatFs requires a
// timer tick every 10 ms for internal timing purposes.
//*****************************************************************************
void
SysTickHandler(void)
{
    // Call the FatFs tick timer.
    disk_timerproc();
}

//*****************************************************************************
// This function implements the "ls" command.  It opens the current
// directory and enumerates through the contents, and prints a line for
// each item it finds.  It shows details such as file attributes, time and
// date, and the file size, along with the name.  It shows a summary of
// file sizes at the end along with free space.
//*****************************************************************************
int
Cmd_ls(int argc, char *argv[])
{
    unsigned long ulTotalSize, ulItemCount, ulFileCount, ulDirCount;
    FRESULT fresult;
    FATFS *pFatFs;

    // Open the current directory for access.
    fresult = f_opendir(&g_sDirObject, g_cCwdBuf);

    // Check for error and return if there is a problem.
    if(fresult != FR_OK)
    {

        return(fresult);
    }

    ulTotalSize = 0;
    ulFileCount = 0;
    ulDirCount = 0;
    ulItemCount = 0;

    // Give an extra blank line before the listing.
    UARTprintf("\n");

    // Enter loop to enumerate through all directory entries.
    for(;;)
    {
        // Read an entry from the directory.
        fresult = f_readdir(&g_sDirObject, &g_sFileInfo);

        // Check for error and return if there is a problem.
        if(fresult != FR_OK)
        {
            return(fresult);
        }

        // If the file name is blank, then this is the end of the
        // listing.
        if(!g_sFileInfo.fname[0])
        {
            break;
        }

        // Print the entry information on a single line with formatting
        // to show the attributes, date, time, size, and name.
        UARTprintf("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9u  %s\n",
                   (g_sFileInfo.fattrib & AM_DIR) ? 'D' : '-',
                   (g_sFileInfo.fattrib & AM_RDO) ? 'R' : '-',
                   (g_sFileInfo.fattrib & AM_HID) ? 'H' : '-',
                   (g_sFileInfo.fattrib & AM_SYS) ? 'S' : '-',
                   (g_sFileInfo.fattrib & AM_ARC) ? 'A' : '-',
                   (g_sFileInfo.fdate >> 9) + 1980,
                   (g_sFileInfo.fdate >> 5) & 15,
                   g_sFileInfo.fdate & 31,
                   (g_sFileInfo.ftime >> 11),
                   (g_sFileInfo.ftime >> 5) & 63,
                   g_sFileInfo.fsize,
                   g_sFileInfo.fname);

        // Add the information as a line in the listbox widget.
        if(ulItemCount < NUM_LIST_STRINGS)
        {
            usprintf(g_pcFilenames[ulItemCount], "(%c) %12s",
                     (g_sFileInfo.fattrib & AM_DIR) ? 'D' : 'F',
                     g_sFileInfo.fname);
        }

        // If the attribute is directory, then increment the directory count.
        if(g_sFileInfo.fattrib & AM_DIR)
        {
            ulDirCount++;
        }

        // Otherwise, it is a file.  Increment the file count, and
        // add in the file size to the total.
        else
        {
            ulFileCount++;
            ulTotalSize += g_sFileInfo.fsize;
        }

        // Move to the next entry in the item array we use to populate the
        // list box.
        ulItemCount++;

        // Wait for the UART transmit buffer to empty.
        UARTFlushTx(false);

    }   // endfor

    // Print summary lines showing the file, dir, and size totals.
    UARTprintf("\n%4u File(s),%10u bytes total\n%4u Dir(s)",
               ulFileCount, ulTotalSize, ulDirCount);

    // Get the free space.
    fresult = f_getfree("/", &ulTotalSize, &pFatFs);

    // Check for error and return if there is a problem.
    if(fresult != FR_OK)
    {
        return(fresult);
    }

    // Display the amount of free space that was calculated.
    UARTprintf(", %10uK bytes free\n", ulTotalSize * pFatFs->sects_clust / 2);

    // Wait for the UART transmit buffer to empty.
    UARTFlushTx(false);

    // Made it to here, return with no errors.
    return(0);
}

//*****************************************************************************
// This function implements the "cd" command.  It takes an argument
// that specifes the directory to make the current working directory.
// Path separators must use a forward slash "/".  The argument to cd
// can be one of the following:
// * root ("/")
// * a fully specified path ("/my/path/to/mydir")
// * a single directory name that is in the current directory ("mydir")
// * parent directory ("..")
// It does not understand relative paths, so dont try something like this:
// ("../my/new/path")
// Once the new directory is specified, it attempts to open the directory
// to make sure it exists.  If the new path is opened successfully, then
// the current working directory (cwd) is changed to the new path.
// In cases of error, the pulReason parameter will be written with one of
// the following values:
//*****************************************************************************
static FRESULT
ChangeToDirectory(char *pcDirectory, unsigned long *pulReason)
{
    unsigned int uIdx;
    FRESULT fresult;

    // Copy the current working path into a temporary buffer so
    // it can be manipulated.
    strcpy(g_cTmpBuf, g_cCwdBuf);

    // If the first character is /, then this is a fully specified
    // path, and it should just be used as-is.
    if(pcDirectory[0] == '/')
    {
        // Make sure the new path is not bigger than the cwd buffer.
        if(strlen(pcDirectory) + 1 > sizeof(g_cCwdBuf))
        {
            *pulReason = NAME_TOO_LONG_ERROR;
            return(FR_OK);
        }

        // If the new path name (in argv[1])  is not too long, then
        // copy it into the temporary buffer so it can be checked.
        else
        {
            strncpy(g_cTmpBuf, pcDirectory, sizeof(g_cTmpBuf));
        }
    }

    // If the argument is .. then attempt to remove the lowest level
    // on the CWD.
    else if(!strcmp(pcDirectory, ".."))
    {
        // Get the index to the last character in the current path.
        uIdx = strlen(g_cTmpBuf) - 1;

        // Back up from the end of the path name until a separator (/)
        // is found, or until we bump up to the start of the path.
        while((g_cTmpBuf[uIdx] != '/') && (uIdx > 1))
        {
            // Back up one character.
            uIdx--;
        }

        // Now we are either at the lowest level separator in the
        // current path, or at the beginning of the string (root).
        // So set the new end of string here, effectively removing
        // that last part of the path.
        g_cTmpBuf[uIdx] = 0;
    }

    // Otherwise this is just a normal path name from the current
    // directory, and it needs to be appended to the current path.
    else
    {
        // Test to make sure that when the new additional path is
        // added on to the current path, there is room in the buffer
        // for the full new path.  It needs to include a new separator,
        // and a trailing null character.
        if(strlen(g_cTmpBuf) + strlen(pcDirectory) + 1 + 1 > sizeof(g_cCwdBuf))
        {
            *pulReason = NAME_TOO_LONG_ERROR;
            return(FR_INVALID_OBJECT);
        }

        // The new path is okay, so add the separator and then append
        // the new directory to the path.
        else
        {
            // If not already at the root level, then append a /
            if(strcmp(g_cTmpBuf, "/"))
            {
                strcat(g_cTmpBuf, "/");
            }

            // Append the new directory to the path.
            strcat(g_cTmpBuf, pcDirectory);
        }
    }

    // At this point, a candidate new directory path is in chTmpBuf.
    // Try to open it to make sure it is valid.
    fresult = f_opendir(&g_sDirObject, g_cTmpBuf);

    // If it cant be opened, then it is a bad path.  Inform
    // user and return.
    if(fresult != FR_OK)
    {
        *pulReason = OPENDIR_ERROR;
        return(fresult);
    }

    // Otherwise, it is a valid new path, so copy it into the CWD and update
    // the screen.
    else
    {
        strncpy(g_cCwdBuf, g_cTmpBuf, sizeof(g_cCwdBuf));
    }

    // Return success.
    return(FR_OK);
}

//*****************************************************************************
// This function implements the "cd" command.  It takes an argument
// that specifes the directory to make the current working directory.
// Path separators must use a forward slash "/".  The argument to cd
// can be one of the following:
// * root ("/")
// * a fully specified path ("/my/path/to/mydir")
// * a single directory name that is in the current directory ("mydir")
// * parent directory ("..")
// It does not understand relative paths, so dont try something like this:
// ("../my/new/path")
// Once the new directory is specified, it attempts to open the directory
// to make sure it exists.  If the new path is opened successfully, then
// the current working directory (cwd) is changed to the new path.
//*****************************************************************************
int
Cmd_cd(int argc, char *argv[])
{
    unsigned long ulReason;
    FRESULT fresult;

    // Try to change to the directory provided on the command line.
    fresult = ChangeToDirectory(argv[1], &ulReason);

    // If an error was reported, try to offer some helpful information.
    if(fresult != FR_OK)
    {
        switch(ulReason)
        {
        case OPENDIR_ERROR:
            UARTprintf("Error opening new directory.\n");
            break;

        case NAME_TOO_LONG_ERROR:
            UARTprintf("Resulting path name is too long.\n");
            break;

        default:
            UARTprintf("An unrecognized error was reported.\n");
            break;
        }
    }

    // Return the appropriate error code.
    return(fresult);
}

//*****************************************************************************
// This function implements the "pwd" command.  It simply prints the
// current working directory.
//*****************************************************************************
int
Cmd_pwd(int argc, char *argv[])
{
    // Print the CWD to the console.
    UARTprintf("%s\n", g_cCwdBuf);

    // Wait for the UART transmit buffer to empty.
    UARTFlushTx(false);

    // Return success.
    return(0);
}

//*****************************************************************************
// This function implements the "cat" command.  It reads the contents of
// a file and prints it to the console.  This should only be used on
// text files.  If it is used on a binary file, then a bunch of garbage
// is likely to printed on the console.
//*****************************************************************************
int
Cmd_cat(int argc, char *argv[])
{
    FRESULT fresult;
    unsigned short usBytesRead;

    // First, check to make sure that the current path (CWD), plus
    // the file name, plus a separator and trailing null, will all
    // fit in the temporary buffer that will be used to hold the
    // file name.  The file name must be fully specified, with path,
    // to FatFs.
    if(strlen(g_cCwdBuf) + strlen(argv[1]) + 1 + 1 > sizeof(g_cTmpBuf))
    {
        UARTprintf("Resulting path name is too long\n");
        return(0);
    }

    // Copy the current path to the temporary buffer so it can be manipulated.
    strcpy(g_cTmpBuf, g_cCwdBuf);

    // If not already at the root level, then append a separator.
    if(strcmp("/", g_cCwdBuf))
    {
        strcat(g_cTmpBuf, "/");
    }

    // Now finally, append the file name to result in a fully specified file.
    strcat(g_cTmpBuf, argv[1]);

    // Open the file for reading.
    fresult = f_open(&g_sFileObject, g_cTmpBuf, FA_READ);

    // If there was some problem opening the file, then return
    // an error.
    if(fresult != FR_OK)
    {
        return(fresult);
    }

    // Enter a loop to repeatedly read data from the file and display it,
    // until the end of the file is reached.
    do
    {
        // Read a block of data from the file.  Read as much as can fit
        // in the temporary buffer, including a space for the trailing null.
        fresult = f_read(&g_sFileObject, g_cTmpBuf, sizeof(g_cTmpBuf) - 1,
                         &usBytesRead);

        // If there was an error reading, then print a newline and
        // return the error to the user.
        if(fresult != FR_OK)
        {
            UARTprintf("\n");
            return(fresult);
        }

        // Null terminate the last block that was read to make it a
        // null terminated string that can be used with printf.
        g_cTmpBuf[usBytesRead] = 0;

        // Print the last chunk of the file that was received.
        UARTprintf("%s", g_cTmpBuf);

        // Wait for the UART transmit buffer to empty.
        UARTFlushTx(false);

        // Continue reading until less than the full number of bytes are
        // read.  That means the end of the buffer was reached.
    }
    while(usBytesRead == sizeof(g_cTmpBuf) - 1);

    // Return success.
    return(0);
}

//*****************************************************************************
// This function implements the "help" command.  It prints a simple list
// of the available commands with a brief description.
//*****************************************************************************
int
Cmd_help(int argc, char *argv[])
{
    tCmdLineEntry *pEntry;

    // Print some header text.
    UARTprintf("\nAvailable commands\n");
    UARTprintf("------------------\n");

    // Point at the beginning of the command table.
    pEntry = &g_sCmdTable[0];

    // Enter a loop to read each entry from the command table.  The
    // end of the table has been reached when the command name is NULL.
    while(pEntry->pcCmd)
    {
        // Print the command name and the brief description.
        UARTprintf("%s%s\n", pEntry->pcCmd, pEntry->pcHelp);

        // Advance to the next entry in the table.
        pEntry++;

        // Wiat for the UART to catch up.
        UARTFlushTx(false);
    }

    // Return success.
    return(0);
}

//*****************************************************************************
// This is the table that holds the command names, implementing functions,
// and brief description.
//*****************************************************************************
tCmdLineEntry g_sCmdTable[] =
{
    { "help",   Cmd_help,      " : Display list of commands" },
    { "h",      Cmd_help,   "    : alias for help" },
    { "?",      Cmd_help,   "    : alias for help" },
    { "ls",     Cmd_ls,      "   : Display list of files" },
    { "chdir",  Cmd_cd,         ": Change directory" },
    { "cd",     Cmd_cd,      "   : alias for chdir" },
    { "pwd",    Cmd_pwd,      "  : Show current working directory" },
    { "cat",    Cmd_cat,      "  : Show contents of a text file" },
    { 0, 0, 0 }
};

//*****************************************************************************
// The error routine that is called if the driver library encounters an error.
//*****************************************************************************
#ifdef DEBUG
void
__error__(char *pcFilename, unsigned long ulLine)
{
}

#endif

//*****************************************************************************
// The program main function.  It performs initialization, then runs
// a command processing loop to read commands from the console.
//*****************************************************************************
int
main(void)
{
    int nStatus;
    FRESULT fresult;

    // Disable Protection
    HWREG(SYSCTL_MWRALLOW) =  0xA5A5A5A5;

    // Setup main clock tree for 75MHz - M3 and 150MHz - C28x
    SysCtlClockConfigSet(SYSCTL_SYSDIV_1 | SYSCTL_M3SSDIV_2 | SYSCTL_USE_PLL |
                         (SYSCTL_SPLLIMULT_M & 0x0F));

    // Configure SysTick for a 100Hz interrupt.
    SysTickPeriodSet(SysCtlClockGet(SYSTEM_CLOCK_SPEED) / TICKS_PER_SECOND);
    SysTickEnable();
    SysTickIntEnable();

    // Register interrupt handlers in the RAM vector table
    IntRegister(FAULT_SYSTICK, SysTickHandler);

    // Enable Interrupts
    IntMasterEnable();

    // Set GPIO E4 and E5 as UART.
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
    GPIOPinTypeUART(GPIO_PORTE_BASE, GPIO_PIN_4 | GPIO_PIN_5);
    GPIOPinConfigure(GPIO_PE4_U0RX);
    GPIOPinConfigure(GPIO_PE5_U0TX);

    // Initialize the UART as a console for text I/O.
    UARTStdioInit(0);
    IntRegister(INT_UART0, UARTStdioIntHandler);

    // Print hello message to user.
    UARTprintf("\n\nSD Card Example Program\n");
    UARTprintf("Type \'help\' for help.\n");

    // Mount the file system, using logical disk 0.
    fresult = f_mount(0, &g_sFatFs);
    if(fresult != FR_OK)
    {
        UARTprintf("f_mount error: %s\n", StringFromFresult(fresult));
        return(1);
    }

    // Enter an (almost) infinite loop for reading and processing commands from
    //the user.
    while(1)
    {
        // Print a prompt to the console.  Show the CWD.
        UARTprintf("\n%s> ", g_cCwdBuf);

        // Get a line of text from the user.
        UARTgets(g_cCmdBuf, sizeof(g_cCmdBuf));

        // Pass the line from the user to the command processor.
        // It will be parsed and valid commands executed.
        nStatus = CmdLineProcess(g_cCmdBuf);

        // Handle the case of bad command.
        if(nStatus == CMDLINE_BAD_CMD)
        {
            UARTprintf("Bad command!\n");
        }

        // Handle the case of too many arguments.
        else if(nStatus == CMDLINE_TOO_MANY_ARGS)
        {
            UARTprintf("Too many arguments for command processor!\n");
        }

        // Otherwise the command was executed.  Print the error
        // code if one was returned.
        else if(nStatus != 0)
        {
            UARTprintf("Command returned error code %s\n",
                       StringFromFresult((FRESULT)nStatus));
        }
    }
}

// TI File $Revision:
// Checkin $Date:
//###########################################################################
//
// FILE:   F2806x_Spi.c
//
// TITLE:  F2806x SPI Initialization & Support Functions.
//
//###########################################################################
// $TI Release:  $
// $Release Date:  $
//###########################################################################

#include "DSP2803x_Device.h"     // F2806x Headerfile Include File
#include "DSP2803x_Examples.h"   // F2806x Examples Include File

static unsigned int rxdatabuf[128];
static unsigned short rx_index=0;

static unsigned int lastTX;

//---------------------------------------------------------------------------
// InitSPI:
//---------------------------------------------------------------------------
// This function initializes the SPI(s) to a known state.
// The peripheral clock for this module must be enabled before calling 
void InitSpi(volatile struct SPI_REGS *Spi_Regs, unsigned int CR_options, unsigned int CTL_options, unsigned char BRR)
{
   // Initialize SPI-A/B
   
   //Reset the selected SPI peripheral
   Spi_Regs->SPICCR.bit.SPISWRESET = 0;
   asm(" nop");

   
   Spi_Regs->SPIBRR = BRR;
   
   //Copy requested config into Control Registers
   Spi_Regs->SPICCR.all = CR_options;
   Spi_Regs->SPICTL.all = CTL_options;
   
   Spi_Regs->SPIFFTX.bit.SPIFFENA = 0; 
   
   Spi_Regs->SPICCR.bit.SPISWRESET = 1;
   asm(" nop");

//	Spi_Regs->SPICCR.all =0x0007;	    //Reset off, rising edge, 8-bit char bits  
//	Spi_Regs->SPICTL.all =0x000E;        //Enable master mode, delayed phase,
//                                        //enable talk, and SPI int disabled.
//	Spi_Regs->SPIBRR =0x0046;									
//    Spi_Regs->SPICCR.all =0x0087;		//Relinquish SPI from Reset 
//    Spi_Regs->SPIPRI.bit.FREE = 1; 		//Transmission not affected by emulator
   //tbd...

}


//All data passed into or out of these functions is right justified
//Data Put must convert data into left justified 
//Functions are blocking
void SPIDataPut(volatile struct SPI_REGS *Spi_Regs, unsigned int TXData){
	
	//wait until the FIFO isn't full
	while(Spi_Regs->SPISTS.bit.BUFFULL_FLAG);
	lastTX = TXData;
	//Shift and copy transmit data into buffer such that it is left justified
	Spi_Regs->SPITXBUF = (TXData << (15 - Spi_Regs->SPICCR.bit.SPICHAR) & 0xFF00);
	
	rx_index++;
}

void SPIDataGet(volatile struct SPI_REGS *Spi_Regs, unsigned int *RXData){
//	if(Spi_Regs->SPIFFRX.bit.RXFFST == 0){
//		*RXData = 0;
//		return;
//	}
	
	if(rx_index==31)
		asm(" nop");
	
	while(Spi_Regs->SPISTS.bit.INT_FLAG != 0)
	//Copy Data from read buffer
	*RXData = Spi_Regs->SPIRXBUF ;
	rxdatabuf[rx_index]= *RXData;

}

unsigned int spi_xmit(volatile struct SPI_REGS *Spi_Regs, unsigned int byte){
	Spi_Regs->SPITXBUF = byte;         			//Transmit Byte
	while(Spi_Regs->SPISTS.bit.INT_FLAG != 1); 	//Wait until the RXBUF has received last bit
	asm(" nop");
	asm(" nop");
	rxdatabuf[rx_index] = Spi_Regs->SPIRXBUF;
	rx_index++;
  	return rxdatabuf[rx_index-1];			//Read Byte from RXBUF and return
	
}

//---------------------------------------------------------------------------
// Example: InitSpiGpio:
//---------------------------------------------------------------------------
// This function initializes GPIO pins to function as SPI pins
//
// Each GPIO pin can be configured as a GPIO pin or up to 3 different
// peripheral functional pins. By default all pins come up as GPIO
// inputs after reset.
//
// Caution:
// For each SPI peripheral
// Only one GPIO pin should be enabled for SPISIMO operation.
// Only one GPIO pin should be enabled for SPISOMI operation.
// Only one GPIO pin should be enabled for SPICLKA operation.
// Only one GPIO pin should be enabled for SPISTEA operation.
// Comment out other unwanted lines.

//void InitSpiGpio()
//{
//
//   InitSpiaGpio();
//   InitSpibGpio();
//
//}

//void InitSpiaGpio()
//{
//
//   EALLOW;
///* Enable internal pull-up for the selected pins */
//// Pull-ups can be enabled or disabled by the user.
//// This will enable the pullups for the specified pins.
//// Comment out other unwanted lines.
//
//    GpioCtrlRegs.GPAPUD.bit.GPIO3 = 0;   // Enable pull-up on GPIO3 (SPISOMIA)
//    GpioCtrlRegs.GPAPUD.bit.GPIO5 = 0;   // Enable pull-up on GPIO5 (SPISIMOA)
//
//    GpioCtrlRegs.GPAPUD.bit.GPIO16 = 0;   // Enable pull-up on GPIO16 (SPISIMOA)
//    GpioCtrlRegs.GPAPUD.bit.GPIO17 = 0;   // Enable pull-up on GPIO17 (SPISOMIA)
//    GpioCtrlRegs.GPAPUD.bit.GPIO18 = 0;   // Enable pull-up on GPIO18 (SPICLKA)
//    GpioCtrlRegs.GPAPUD.bit.GPIO19 = 0;   // Enable pull-up on GPIO19 (SPISTEA)
//
//    GpioCtrlRegs.GPBPUD.bit.GPIO54 = 0;   // Enable pull-up on GPIO54 (SPISIMOA)
//    GpioCtrlRegs.GPBPUD.bit.GPIO55 = 0;   // Enable pull-up on GPIO55 (SPISOMIA)
//    GpioCtrlRegs.GPBPUD.bit.GPIO56 = 0;   // Enable pull-up on GPIO56 (SPICLKA)
//    GpioCtrlRegs.GPBPUD.bit.GPIO57 = 0;   // Enable pull-up on GPIO57 (SPISTEA)
//
///* Set qualification for selected pins to asynch only */
//// This will select asynch (no qualification) for the selected pins.
//// Comment out other unwanted lines.
//
//	GpioCtrlRegs.GPAQSEL1.bit.GPIO3 = 3; // Asynch input GPIO3 (SPISOMIA)
//	GpioCtrlRegs.GPAQSEL1.bit.GPIO5 = 3; // Asynch input GPIO5 (SPISIMOA)
//
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO16 = 3; // Asynch input GPIO16 (SPISIMOA)
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO17 = 3; // Asynch input GPIO17 (SPISOMIA)
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO18 = 3; // Asynch input GPIO18 (SPICLKA)
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO19 = 3; // Asynch input GPIO19 (SPISTEA)
//
//    GpioCtrlRegs.GPBQSEL2.bit.GPIO54 = 3; // Asynch input GPIO54 (SPISIMOA)
//    GpioCtrlRegs.GPBQSEL2.bit.GPIO55 = 3; // Asynch input GPIO55 (SPISOMIA)
//    GpioCtrlRegs.GPBQSEL2.bit.GPIO56 = 3; // Asynch input GPIO56 (SPICLKA)
//    GpioCtrlRegs.GPBQSEL2.bit.GPIO57 = 3; // Asynch input GPIO57 (SPISTEA)
//
//
///* Configure SPI-A pins using GPIO regs*/
//// This specifies which of the possible GPIO pins will be SPI functional pins.
//// Comment out other unwanted lines.
//
//    GpioCtrlRegs.GPAMUX1.bit.GPIO3 = 2; // Configure GPIO3 as SPISOMIA
//    GpioCtrlRegs.GPAMUX1.bit.GPIO5 = 2; // Configure GPIO5 as SPISIMOA
//
//    GpioCtrlRegs.GPAMUX2.bit.GPIO16 = 1; // Configure GPIO16 as SPISIMOA
//    GpioCtrlRegs.GPAMUX2.bit.GPIO17 = 1; // Configure GPIO17 as SPISOMIA
//    GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 1; // Configure GPIO18 as SPICLKA
//    GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 1; // Configure GPIO19 as SPISTEA
//
//    GpioCtrlRegs.GPBMUX2.bit.GPIO54 = 1; // Configure GPIO54 as SPISIMOA
//    GpioCtrlRegs.GPBMUX2.bit.GPIO55 = 1; // Configure GPIO55 as SPISOMIA
//    GpioCtrlRegs.GPBMUX2.bit.GPIO56 = 1; // Configure GPIO56 as SPICLKA
//    GpioCtrlRegs.GPBMUX2.bit.GPIO57 = 1; // Configure GPIO57 as SPISTEA
//
//    EDIS;
//}
//
//void InitSpibGpio()
//{
//
//   EALLOW;
///* Enable internal pull-up for the selected pins */
//// Pull-ups can be enabled or disabled by the user.
//// This will enable the pullups for the specified pins.
//// Comment out other unwanted lines.
//
//    GpioCtrlRegs.GPAPUD.bit.GPIO12 = 0;   // Enable pull-up on GPIO12 (SPISIMOB)
//	GpioCtrlRegs.GPAPUD.bit.GPIO13 = 0;   // Enable pull-up on GPIO13 (SPISOMIB)
//    GpioCtrlRegs.GPAPUD.bit.GPIO14 = 0;   // Enable pull-up on GPIO14 (SPICLKB)
//    GpioCtrlRegs.GPAPUD.bit.GPIO15 = 0;   // Enable pull-up on GPIO15 (SPISTEB)
//
//	GpioCtrlRegs.GPAPUD.bit.GPIO24 = 0;   // Enable pull-up on GPIO24 (SPISIMOB)
//	GpioCtrlRegs.GPAPUD.bit.GPIO25 = 0;   // Enable pull-up on GPIO25 (SPISOMIB)
//    GpioCtrlRegs.GPAPUD.bit.GPIO26 = 0;   // Enable pull-up on GPIO26 (SPICLKB)
//    GpioCtrlRegs.GPAPUD.bit.GPIO27 = 0;   // Enable pull-up on GPIO27 (SPISTEB)
//
///* Set qualification for selected pins to asynch only */
//// This will select asynch (no qualification) for the selected pins.
//// Comment out other unwanted lines.
//
//    GpioCtrlRegs.GPAQSEL1.bit.GPIO12 = 3; // Asynch input GPIO12 (SPISIMOB)
//    GpioCtrlRegs.GPAQSEL1.bit.GPIO13 = 3; // Asynch input GPIO13 (SPISOMIB)
//    GpioCtrlRegs.GPAQSEL1.bit.GPIO14 = 3; // Asynch input GPIO14 (SPICLKB)
//    GpioCtrlRegs.GPAQSEL1.bit.GPIO15 = 3; // Asynch input GPIO15 (SPISTEB)
//
//	GpioCtrlRegs.GPAQSEL2.bit.GPIO24 = 3; // Asynch input GPIO24 (SPISIMOB)
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO25 = 3; // Asynch input GPIO25 (SPISOMIB)
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO26 = 3; // Asynch input GPIO26 (SPICLKB)
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO27 = 3; // Asynch input GPIO27 (SPISTEB)
//
///* Configure SPI-B pins using GPIO regs*/
//// This specifies which of the possible GPIO pins will be SPI functional pins.
//// Comment out other unwanted lines.
//
//    GpioCtrlRegs.GPAMUX1.bit.GPIO12 = 3; // Configure GPIO12 as SPISIMOB
//    GpioCtrlRegs.GPAMUX1.bit.GPIO13 = 3; // Configure GPIO13 as SPISOMIB
//    GpioCtrlRegs.GPAMUX1.bit.GPIO14 = 3; // Configure GPIO14 as SPICLKB
//    GpioCtrlRegs.GPAMUX1.bit.GPIO15 = 3; // Configure GPIO15 as SPISTEB
//
//	GpioCtrlRegs.GPAMUX2.bit.GPIO24 = 3; // Configure GPIO24 as SPISIMOB
//    GpioCtrlRegs.GPAMUX2.bit.GPIO25 = 3; // Configure GPIO25 as SPISOMIB
//    GpioCtrlRegs.GPAMUX2.bit.GPIO26 = 3; // Configure GPIO26 as SPICLKB
//    GpioCtrlRegs.GPAMUX2.bit.GPIO27 = 3; // Configure GPIO27 as SPISTEB
//
//    EDIS;
//}

//===========================================================================
// End of file.
//===========================================================================