//*****************************************************************************
//
//! \brief xspi 004 test of SPI0 initialization.
//!
//! \return None.
//
//*****************************************************************************
static void SPI0MasterInit(void)
{
//
// Configure Some GPIO pins as SPI Mode
//
xSPinTypeSPI(SPI0CLK, PB13);
xSPinTypeSPI(SPI0MOSI, PB15);
xSPinTypeSPI(SPI0MISO, PB14);
xSPinTypeSPI(SPI0CS, PA7);
//
// Master Mode polarity 0,Rx latched at rising edge Tx changed at rising edge
// 200000Hz 8Bits Data windth SPI MSB First
//
xSPIConfigSet(SPI0_BASE, 10000, SPI_FORMAT_MODE_5 | SPI_DATA_WIDTH16 |
SPI_MSB_FIRST | SPI_MODE_MASTER);
//
// Software Control Transfer Select SS0
//
xSPISSSet(SPI0_BASE, xSPI_SS_SOFTWARE, 0);
// SPISSClear(SPI0_BASE);
// xIntEnable(INT_SPI0);
xSPIIntCallbackInit(SPI0_BASE, SPI0Callback);
xSPIEnable(SPI0_BASE);
// xIntPrioritySet(INT_SPI0, 1);
// xSPIIntEnable(SPI0_BASE, xSPI_INT_EOT);
// SPIFIFOLevelSet(SPI0_BASE, SPI_FSR_RX, 5);
}
//*****************************************************************************
//
//! \brief Init Spi communction port and wifi handshake pin.
//
//! WiFi shield IO refence volatge == 3.3V
//! Pin map is below:
//! HAND_PIN --> PA3
//! SPI1_NSS --> PA4
//! SPI1_SCK --> PA5
//! SPI1_MISO --> PA6
//! SPI1_MOSI --> PA7
//!
//! \param none.
//!
//! \return None
//
//*****************************************************************************
void SpiDrv_Init(void)
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xGPIOSPinTypeGPIOInput(PA3);
xGPIOSPinTypeGPIOOutput(PA4);
xSPinTypeSPI(SPI1CLK(3), PA5);
xSPinTypeSPI(SPI1MOSI(3), PA7);
xSPinTypeSPI(SPI1MISO(1), PA6);
//
// Configure MCU as a master device , 8 bits data width ,MSB first,Mode_0
//
xSPIConfigSet(xSPI1_BASE, 4000000, xSPI_MOTO_FORMAT_MODE_0 |
xSPI_MODE_MASTER |
xSPI_MSB_FIRST |
xSPI_DATA_WIDTH8);
xSPISSSet(xSPI1_BASE, xSPI_SS_SOFTWARE, xSPI_SS0);
xSPIEnable(xSPI1_BASE);
}
//*****************************************************************************
//
//! \brief Initialize TC77
//!
//! \param ulClock specifies the SPI Clock Rate
//!
//! This function is to initialize the MCU as master and specified SPI port.Set
//! TC77_PIN_SPI_CS as CS, TC77_PIN_SPI_CLK as CLK, TC77_PIN_SPI_MISO ->MISO and
//! TC77_PIN_SPI_MOSI->MOSI,most of all it check the first conversion is finished
//! or not in order to execute the following operation.
//!
//! \return None.
//
//*****************************************************************************
void
TC77Init(unsigned long ulSpiClock)
{
short sReadValue = 0;
//
// The max clock rate of TC77 is 7M Hz acoording to Datasheet, Otherwise
// it will generate bigger error
//
xASSERT((ulSpiClock > 0) && (ulSpiClock < 7000000));
//
// Enable the GPIOx port which is connected with tc77
//
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(TC77_PIN_SPI_MISO));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(TC77_PIN_SPI_MOSI));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(TC77_PIN_SPI_CLK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(TC77_PIN_SPI_CS));
//
// Enable the SPIx which is connected with tc77
//
xSysCtlPeripheralEnable2(TC77_PIN_SPI_PORT);
//
// Set TC77_PIN_SPI_CS as a chip select pin and set it as OUT_MODE
//
xGPIOSPinDirModeSet(TC77_PIN_SPI_CS, xGPIO_DIR_MODE_OUT);
//
// Set TC77_PIN_SPI_CLK as SPIx.CLK
//
xSPinTypeSPI(TC77_SPI_CLK, TC77_PIN_SPI_CLK);
//
// Set TC77_PIN_SPI_MISO as SPIx.MISO
//
xSPinTypeSPI(TC77_SPI_MISO, TC77_PIN_SPI_MISO);
//
// Configure MCU as a master device , 16 bits data width ,MSB first,Mode_0
//
xSPIConfigSet(TC77_PIN_SPI_PORT, ulSpiClock, xSPI_MOTO_FORMAT_MODE_0 |
xSPI_DATA_WIDTH16 |
xSPI_MODE_MASTER |
xSPI_MSB_FIRST);
//
// Disable TC77 when Power up
//
xGPIOSPinWrite(TC77_PIN_SPI_CS, 1);
//
// Wait for the first conversion completed
//
while(!(0x0004 & sReadValue))
{
sReadValue = TC77TemperRead();
}
}
//*****************************************************************************
//
//! \brief Initialize AT45DB161 and SPI
//!
//! \param ulSpiClock specifies the SPI Clock Rate
//!
//! This function initialize the mcu SPI as master and specified SPI port.
//! After SPI and port was configured, the mcu send a AT45DB161_CMD_SRRD command
//! to get the page size of AT45DB161 to get prepareed for the followed read and
//! write operations.
//!
//! \return None.
//
//*****************************************************************************
void AT45DB161_Init(unsigned long ulSpiClock)
{
unsigned char tmp;
xASSERT((ulSpiClock > 0) && (ulSpiClock < AT45DB161_MAX_CLK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(AT45DB161_SCK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(AT45DB161_CS_PIN));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(AT45DB161_MISO));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(AT45DB161_MOSI));
xSysCtlPeripheralEnable2(AT45DB161_SPI_PORT);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xGPIOSPinDirModeSet(AT45DB161_CS_PIN, xGPIO_DIR_MODE_OUT);
#if (AT45DB161_WRITE_PROTECT < 1)
xGPIOSPinDirModeSet(FLASH_PIN_WRITE_PROTECT, xGPIO_DIR_MODE_OUT);
xGPIOSPinWrite(FLASH_PIN_WRITE_PROTECT, 0);
#endif
//
// PD1 as SPI2.CLK
//
xSPinTypeSPI(SPI_CLK, AT45DB161_SCK);
//
// PD2 as SPI2.MISO
// MISO20 => SPI0MISO
//
xSPinTypeSPI(SPI_MISO, AT45DB161_MISO);
//
// PD3 as SPI2.MOSI
// MOSI20 => SPI0MISO
//
xSPinTypeSPI(SPI_MOSI, AT45DB161_MOSI);
//xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
//
//! Set SPI mode.
//
xSPIConfigSet(AT45DB161_SPI_PORT, ulSpiClock, SPI_MODE_MASTER |
SPI_MSB_FIRST |
SPI_2LINE_FULL |
SPI_DATA_WIDTH8 |
SPI_FORMAT_MODE_4);
SPISSModeConfig(AT45DB161_SPI_PORT, SPI_CR1_SSM);
SPISSIConfig(AT45DB161_SPI_PORT, SPI_CR1_SSI);
SPIEnble(AT45DB161_SPI_PORT);
AT45DB161_CS = 1;
xSPISingleDataReadWrite(AT45DB161_SPI_PORT, 0xFF);
xSysCtlDelay(100000);
AT45DB161_CS = 0;
//
//! Read AT45DB161 state register to get the page size.
//
xSPISingleDataReadWrite(AT45DB161_SPI_PORT, AT45DB161_CMD_SRRD);
tmp = xSPISingleDataReadWrite(AT45DB161_SPI_PORT, 0xFF);
if(tmp & AT45DB161_PGSZ) AT45DB161_PageSize = 512;
AT45DB161_CS = 1;
}
//Initializes the SPI bus by setting SCK, MOSI, and SS to outputs, pulling SCK and MOSI low, and SS high.
void SPIClass::begin(int spiClock){
// Enable Peripheral SPIx
xSysCtlPeripheralEnable2(spiPort);
xSysCtlPeripheralEnable2(xGPIOSPinToPort(sD13));
// Configure Some GPIO pins as SPIx Mode
sPinTypeSPI(spiPort);
ulDataWidth = xSPI_DATA_WIDTH8;
ulDataFormat = SPI_MODE0;
ulDataMode = MSBFIRST;
xSPIConfigSet(spiPort, spiClock, xSPI_MOTO_FORMAT_MODE_0 | xSPI_DATA_WIDTH8 | xSPI_MSB_FIRST | xSPI_MODE_MASTER);
xSPISSSet(spiPort, xSPI_SS_HARDWARE, xSPI_SS0);
xSPIEnable(spiPort);
}
//////////////////////////////////////////////////////////////////////////////
// Platform (STM32F103X) initialization for peripherals as GPIO, SPI, UARTs //
//////////////////////////////////////////////////////////////////////////////
void platform_init(void)
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlDelay((xSysCtlClockGet()/1000)*50); // wait 50ms
/**************************/
/* GPIO_A For SPI CS PIN */// It must be first to enable GPIO peripheral than other peripheral. (Otherwise, UART do not run in STM32F103X)
/**************************/
xSysCtlPeripheralEnable( xSYSCTL_PERIPH_GPIOA );
xGPIODirModeSet(xGPIO_PORTA_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT);
/************/
/* For UART */
/************/
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART1);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART1);
xSPinTypeUART(UART1TX,PA9);
xSPinTypeUART(UART1RX,PA10);
xUARTConfigSet(xUART1_BASE, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
xUARTEnable(xUART1_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
/***********/
/* For SPI */
/***********/
xSysCtlPeripheralReset(WIZCHIP_SPI_PERIPH);
xSysCtlPeripheralEnable(WIZCHIP_SPI_PERIPH);
xSPinTypeSPI(WIZCHIP_SPI_CLK, WIZCHIP_SPI_CLK_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_5, GPIO_TYPE_AFOUT_STD, GPIO_OUT_SPEED_50M);
xSPinTypeSPI(WIZCHIP_SPI_MOSI,WIZCHIP_SPI_MOSI_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_7, GPIO_TYPE_AFOUT_STD, GPIO_OUT_SPEED_50M);
xSPinTypeSPI(WIZCHIP_SPI_MISO,WIZCHIP_SPI_MISO_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_6, GPIO_TYPE_IN_FLOATING, GPIO_IN_SPEED_FIXED);
xSPIConfigSet(WIZCHIP_SPI_BASE, xSysCtlClockGet()/2, xSPI_MOTO_FORMAT_MODE_0 | xSPI_MODE_MASTER | xSPI_MSB_FIRST | xSPI_DATA_WIDTH8);
xSPISSSet(WIZCHIP_SPI_BASE, SPI_SS_SOFTWARE, xSPI_SS_NONE);
xSPIEnable(WIZCHIP_SPI_BASE);
printf("HCLK = %dMHz\r\n", (unsigned int)(xSysCtlClockGet()/1000000));
}
static void xspi004_MasterIntFunction(void)
{
unsigned long i, ulTemp=0;
//
// Configure Some GPIO pins as SPI Mode
//
xSPinTypeSPI(SPI0CLK, PC5);
xSPinTypeSPI(SPI0CS, PC4);
xSPinTypeSPI(SPI0MISO, PC7);
xSPinTypeSPI(SPI0MOSI, PC6);
//xHWREGB(xSPI0_BASE + SPI_C1) = 0x54;
//xHWREGB(xSPI0_BASE + SPI_C2) = 0x80;
//xHWREGB(xSPI0_BASE + SPI_BR) = 0x00;
//xHWREGB(xSPI0_BASE + SPI_M) = 0x04;
//
// Master Mode polarity 0,Rx latched at rising edge Tx changed at rising edge
// 2000000Hz 8Bits Data windth SPI MSB First
//
ulTemp = xSPI_MOTO_FORMAT_MODE_0 | xSPI_MODE_MASTER | xSPI_MSB_FIRST;
xSPIConfigSet(xSPI0_BASE, 20000, ulTemp);
xSPIEnable(xSPI0_BASE);
xIntEnable(INT_SPI0);
xIntPrioritySet(INT_SPI0, 1);
xSPIIntCallbackInit(xSPI0_BASE, SPI0Callback);
xSPIIntEnable(xSPI0_BASE, SPI_SPTEF | SPI_SPRF);
while(!ulFlag);
for(i = 0; i < 8; i++)
{
TestAssert((ulSourceData[i] == ulDestData[i]), "xspi API error!");
ulSourceData[i] = 0;
}
}
//*****************************************************************************
//
//! Ininite the SPI case which is needed
//!
//! \param None
//!
//! This function ininite the SPI including clock source and enable spi
//!
//! \return none
//
//*****************************************************************************
void SpiReceiveTransferInit(void)
{
//
// Set SysClk 36MHz using Extern 12M oscillator
//
xSysCtlClockSet(12000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_25MHZ);
//
// Enable Peripheral SPI0
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI1);
//
// Configure Some GPIO pins as SPI Mode
//
xSPinTypeSPI(SPI1CLK(1), PA5);
xSPinTypeSPI(SPI1MOSI(1), PA7);
xSPinTypeSPI(SPI1MISO(1), PA6);
xSPinTypeSPI(SPI1CS(1), PA4);
xSPIConfigSet(SPI1_BASE, 200000, xSPI_MOTO_FORMAT_MODE_0 | xSPI_DATA_WIDTH8 |
xSPI_MSB_FIRST | xSPI_MODE_SLAVE);
}
//*****************************************************************************
//
//! \brief MCU communication port initialize
//!
//! \param None
//!
//! \return None.
//
//*****************************************************************************
void CH376PortInit( void )
{
#ifdef CH376_INT_WIRE
xSysCtlPeripheralEnable2(CH376_INT_PORT);
xGPIOSPinDirModeSet(CH376_INT_PIN, xGPIO_DIR_MODE_IN); //pass
xGPIOSPinWrite(CH376_INT_PIN, 1);
#endif
#ifdef CH376_USE_HARDWARE_SPI
xSysCtlPeripheralEnable2(CH376_SPI_CS_PORT);
xGPIOSPinDirModeSet(CH376_SPI_CS_PIN, xGPIO_DIR_MODE_OUT);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_SCK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_MOSI));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_MISO));
xSysCtlPeripheralEnable2(CH376_SPI_PORT);
xSPinTypeSPI(CH376SPI_CLK, CH376_SCK);
xSPinTypeSPI(CH376SPI_MISO, CH376_MISO);
xSPinTypeSPI(CH376SPI_MOSI, CH376_MOSI);
xSPIConfigSet(CH376_SPI_PORT, CH376_CLK_FREQ, SPI_MODE_MASTER |
xSPI_MOTO_FORMAT_MODE_3 |
xSPI_MODE_MASTER |
xSPI_MSB_FIRST |
xSPI_DATA_WIDTH8);
// SPISSModeConfig(CH376_SPI_PORT, SPI_CR1_SSM);
// SPISSIConfig(CH376_SPI_PORT, SPI_CR1_SSI);
xSPISSSet( CH376_SPI_PORT, xSPI_SS_SOFTWARE, xSPI_SS0 );
SPIEnble(CH376_SPI_PORT);
CH376_SPI_CS_SET;
#endif //End of CH376_USE_HARDWARE_SPI define
#ifdef CH376_USE_SOFTWARE_SPI
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_SCK_PIN));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_MISO_PIN));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_MOSI_PIN));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(CH376_SPI_CS_PIN));
xGPIOSPinDirModeSet(CH376_SPI_CS_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_SCK_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_MOSI_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_MISO_PIN, xGPIO_DIR_MODE_IN);
CH376_SPI_CS_SET;
#endif //End of CH376_USE_SOFTWARE_SPI define
#ifdef CH376_USE_PARALLEL
xSysCtlPeripheralEnable2(CH376_WR_PORT);
xSysCtlPeripheralEnable2(CH376_RD_PORT);
xSysCtlPeripheralEnable2(CH376_A0_PORT);
xSysCtlPeripheralEnable2(CH376_PCS_PORT);
xSysCtlPeripheralEnable2(CH376_DATA_PORT);
xGPIOSPinDirModeSet(CH376_WR_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_RD_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_A0_PIN, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(CH376_PCS_PIN, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( CH376_DATA_PORT, 0xFF, xGPIO_DIR_MODE_IN );
CH376_PCS_SET;
CH376_WR_SET;
CH376_RD_SET;
CH376_A0_CLR;
#endif //End of CH376_USE_PARALLEL define
}
//*****************************************************************************
//
//! \brief Init the HD44780 LCD Device.
//!
//! \param None.
//!
//! This function is used to Init the HD44780 Device. It must be call before
//! any other LCD function use.
//!
//! It Open the pins's GPIO peripheral port, and config the pins type to GPIO
//! output. Then config the LCD into the default state, clear the LCD and
//! Open the display. Default A Blink cursor is set on. The LCD cursor move
//! direction is config as increment default.
//!
//! The HD44780 Initial state can be determined by the \ref HD44780_Config.
//! - Pins that used is determined by \ref HD44780_Config_Pins.
//! - The inteface data length is determined by \ref HD44780_INTERFACE_DATA_LEN.
//! - The LCD display line is determined by \ref HD44780_DISPLAY_LINE.
//! - The LCD character font is determined by \ref HD44780_CHARACTER_FONT.
//! .
//!
//! \return None.
//
//*****************************************************************************
void
HD44780Init(void)
{
ucDisplayFunction = (HD44780_INTERFACE_DATA_LEN |
HD44780_FUNCTION_SET_N_2 |
HD44780_CHARACTER_FONT);
ucRsPin = 1;
ucRwPin = 255;
ucEnablePin = 2;
ucDataPin[0] = 6;
ucDataPin[1] = 5;
ucDataPin[2] = 4;
ucDataPin[3] = 3;
_SPIbuff = 0;
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(HD44780_PIN_CS));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(HD44780_PIN_CLK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(HD44780_PIN_MOSI));
#if HD44780_SPI_MODE == SPIMODE_HARDWARE
//
// Enable Peripheral SPI1
//
xSysCtlPeripheralEnable2(HD44780_SPI);
SysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
//
// Configure Some GPIO pins as SPI Mode SPI MISO is no use in LCD4884
//
xSPinTypeSPI(HD44780_CLK,HD44780_PIN_CLK);
xSPinTypeSPI(HD44780_MOSI,HD44780_PIN_MOSI);
xGPIOSPinTypeGPIOOutput(HD44780_PIN_CS);
//
// Configure SPI SPI1,ulRate
//
xSPIConfigSet((HD44780_SPI), HD44780_SPI_BAUDRATE,
SPI_FORMAT_MODE_3 | SPI_DATA_WIDTH8 | SPI_MSB_FIRST | SPI_MODE_MASTER);
//
//! \note Enanble SPI SS,test on M0516LBN.other mcu there may need modify.
//
xSPISSSet((HD44780_SPI), xSPI_SS_SOFTWARE, xSPI_SS0);
xSPIEnable(HD44780_SPI);
#else
//
// Set Pins Type to GPIO Output
//
xGPIOSPinTypeGPIOOutput(HD44780_PIN_CS);
xGPIOSPinTypeGPIOOutput(HD44780_PIN_CLK);
xGPIOSPinTypeGPIOOutput(HD44780_PIN_MOSI);
#endif
//
// Output default value : E disable
//
//
// Set Entry Mode: Interface Data Length, Character Font, Display Line
//
while(HD44780Busy());
HD44780WriteCmd(HD44780_CMD_FUNCTION_SET(HD44780_INTERFACE_DATA_LEN |
HD44780_FUNCTION_SET_N_2 |
HD44780_CHARACTER_FONT));
//
// Display on & Cursor Blink
//
while(HD44780Busy());
HD44780WriteCmd(HD44780_CMD_DISPLAY_CTRL(HD44780_DISPLAY_CTRL_D |
0 |
HD44780_DISPLAY_CTRL_B));
//
// Clear LCD
//
while(HD44780Busy());
HD44780WriteCmd(HD44780_CMD_CLS);
//
// Cursor Move Mode: Increment
//
while(HD44780Busy());
HD44780WriteCmd(HD44780_CMD_ENTRY_MODE_SET(HD44780_ENTRY_MODE_SET_ID_INC |
0));
}
//*****************************************************************************
//
//! \brief Init the UC1701 LCD.
//!
//! \param ulSpiClock SPI clock to select.
//!
//! This function initialize the mcu SPI as master and specified SPI port.
//!
//! \return None.
//
//*****************************************************************************
void UC1701Init(unsigned long ulSpiClock)
{
//
// Enable the GPIOx port which is connected with UC1701
//
xSysCtlPeripheralEnable(xGPIOSPinToPort(LCD_PIN_SPI_CLK));
xSysCtlPeripheralEnable(xGPIOSPinToPort(LCD_PIN_SPI_CS));
xSysCtlPeripheralEnable(xGPIOSPinToPort(LCD_PIN_SPI_MOSI));
xSysCtlPeripheralEnable(xGPIOSPinToPort(LCD_PIN_CD));
xSysCtlPeripheralEnable(xGPIOSPinToPort(LCD_PIN_RESET));
//
// Enable the SPIx which is connected with UC1701
//
xSysCtlPeripheralEnable2(LCD_PIN_SPI_PORT);
xSysCtlPeripheralReset2(LCD_PIN_SPI_PORT);
//
// Set the chip select pin as OUT_MODE
//
xGPIOSPinDirModeSet(LCD_PIN_SPI_CS, xGPIO_DIR_MODE_OUT);
//
// Set the chip reset pin as OUT_MODE
//
xGPIOSPinDirModeSet(LCD_PIN_CD, xGPIO_DIR_MODE_OUT);
xGPIOSPinDirModeSet(LCD_PIN_RESET, xGPIO_DIR_MODE_OUT);
xSPinTypeSPI(SPI_CLK, LCD_PIN_SPI_CLK);
xSPinTypeSPI(SPI_MOSI, LCD_PIN_SPI_MOSI);
//
// Configure MCU as a master device , 8 bits data width ,MSB first,Mode_0
//
xSPIConfigSet(LCD_PIN_SPI_PORT, ulSpiClock, xSPI_MOTO_FORMAT_MODE_1 |
xSPI_MODE_MASTER |
xSPI_MSB_FIRST |
xSPI_DATA_WIDTH8);
//
// Disable UC1701 when Power up
//
xGPIOSPinWrite(LCD_PIN_SPI_CS, 1);
//
// Reset the chip
//
xGPIOSPinWrite(LCD_PIN_RESET, 0);
delay_ms(2);
xGPIOSPinWrite(LCD_PIN_RESET, 1);
delay_ms(6);
//
// Initial Configuration
//
UC1701CmdWrite(0xe2);//System Reset
UC1701CmdWrite(0x2c);//Power Rise Step1
delay_ms(8);
UC1701CmdWrite(0x2e);//Power Rise Step2
delay_ms(8);
UC1701CmdWrite(0x2f);//Power Rise Step3
delay_ms(8);
UC1701CmdWrite(0x23);
UC1701DoubleCmdWrite(0x81, 0x1f);//Set LCD resistor ratio
UC1701CmdWrite(0xa2);//Bias 1/9
UC1701CmdWrite(0xc0);//Set COM Direction
UC1701CmdWrite(0xa0);//Set SEG Direction
UC1701CmdWrite(0x40);//Set Scroll Line: the first line
UC1701CmdWrite(0xaf);//Display Enable
}
//Sets the SPIx data mode: SPI_MODE0, SPI_MODE1, SPI_MODE2, SPI_MODE3
void SPIClass::setDataMode(cSPIMode ulMode){
xSPIDisable(spiPort);
ulDataFormat = ulMode;
xSPIConfigSet(spiPort, spiClock, ulDataFormat | ulDataWidth | ulDataMode | xSPI_MODE_MASTER);
xSPIEnable(spiPort);
}
/* Sets the SPIx clock divider relative to the system clock.
* the dividers available are 2, 4, 8, 16, 32, 64 or 128. The default setting is SPI_CLOCK_DIV4,
* which sets the clock to 4 MHz like other Arduino boards.
*/
void SPIClass::setClockDivider(uint16_t divider){
xSPIDisable(spiPort);
spiClock = 16000000 / divider;
xSPIConfigSet(spiPort, spiClock, ulDataFormat | ulDataWidth | ulDataMode | xSPI_MODE_MASTER);
xSPIEnable(spiPort);
}
//Sets the order of the bits shifted out of and into the SPIx bus, either LSBFIRST or MSBFIRST.
void SPIClass::setBitOrder(cSPIBitOrder order){
xSPIDisable(spiPort);
ulDataMode = order;
xSPIConfigSet(spiPort, spiClock, ulDataFormat | ulDataWidth | ulDataMode | xSPI_MODE_MASTER);
xSPIEnable(spiPort);
}