//*****************************************************************************
//
//! \brief System and PWM Initialize.
//!
//! \param None
//!
//! \note None.
//!
//! \return None.
//
//*****************************************************************************
void xSysCtlAndPwmInit(void)
{
unsigned long i = 0;
unsigned long ulBit = 0;
//
// Set System clock is 48M
//
xSysCtlClockSet(48000000, (xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ));
//
// Enable GPIO and PWM
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOC);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOC);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOE);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOE);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_PWMB);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMB);
//
// Set PE2(DIR_CLK), PD3(DIR_SER), and PA6(DIR_LATCH) PD2(DIR_EN) as output
//
xGPIOSPinTypeGPIOOutput(sD4);
xGPIOSPinTypeGPIOOutput(sD8);
xGPIOSPinTypeGPIOOutput(sD12);
xGPIOSPinTypeGPIOOutput(sD7);
//
// Set PWM Clock Source
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_PWMA_MAIN, 4);
xSysCtlPeripheralClockSourceSet(xSYSCTL_PWMB_MAIN, 4);
//
// Congigure the PWM pin(PWM7, sD11))
//
sD11PinTypePWM();
//xGPIOSPinTypeGPIOOutput(sD11);
//xGPIOSPinWrite(sD11, 1);
//
// 74HC595 operation
// Output Enable
//
SendData74HC595(0x60);
}
void GPIO_Example_LED_Blink(void)
{
/********************** Configure System clock *************************/
SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ);
SysCtlDelay(TICK_SLOW);
// Enable LED PORT
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
// Configure LED(PC3) pin into output mode.
xGPIOSPinTypeGPIOOutput(PC3);
xGPIOSPinDirModeSet(PC3,xGPIO_DIR_MODE_OUT);
while(1)
{
// LED ON
xGPIOSPinWrite(PC3,1);
xSysCtlDelay(10*TICK_SLOW);
// LED OFF
xGPIOSPinWrite(PC3,0);
xSysCtlDelay(10*TICK_SLOW);
}
}
//*****************************************************************************
//
//! \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 Read the state or data from the ST7735.
//!
//! \param ucRS determines if the IR or DR to select.
//!
//! The parameter of ucDC can be:
//! - ST7735_RS_COMMAND - select the IR.
//! - ST7735_RS_DATA - select the DR.
//!
//! \return None.
//
//*****************************************************************************
unsigned long
ST7735Read(unsigned char ucRS)
{
unsigned long ulData = 0;
//
// Set D7 - D0 direction to GPIO Input
//
xGPIOSPinTypeGPIOInput(ST7735_PIN_D7);
xGPIOSPinTypeGPIOInput(ST7735_PIN_D6);
xGPIOSPinTypeGPIOInput(ST7735_PIN_D5);
xGPIOSPinTypeGPIOInput(ST7735_PIN_D4);
xGPIOSPinTypeGPIOInput(ST7735_PIN_D3);
xGPIOSPinTypeGPIOInput(ST7735_PIN_D2);
xGPIOSPinTypeGPIOInput(ST7735_PIN_D1);
xGPIOSPinTypeGPIOInput(ST7735_PIN_D0);
//
// DC:Command, RD:Write/Read, CS:Enable
//
xGPIOSPinWrite(ST7735_PIN_RS, ucRS);
xGPIOSPinWrite(ST7735_PIN_WR, ST7735_WR_HIGH);
xGPIOSPinWrite(ST7735_PIN_CS, ST7735_CS_ENABLE);
xSysCtlDelay(100);
//
// Read the Data
//
xGPIOSPinWrite(ST7735_PIN_RD, ST7735_RD_LOW);
xSysCtlDelay(100);
xGPIOSPinWrite(ST7735_PIN_RD, ST7735_RD_HIGH);
ulData |= xGPIOSPinRead(ST7735_PIN_D7) << 7;
ulData |= xGPIOSPinRead(ST7735_PIN_D6) << 6;
ulData |= xGPIOSPinRead(ST7735_PIN_D5) << 5;
ulData |= xGPIOSPinRead(ST7735_PIN_D4) << 4;
ulData |= xGPIOSPinRead(ST7735_PIN_D3) << 3;
ulData |= xGPIOSPinRead(ST7735_PIN_D2) << 2;
ulData |= xGPIOSPinRead(ST7735_PIN_D1) << 1;
ulData |= xGPIOSPinRead(ST7735_PIN_D0) << 0;
xGPIOSPinWrite(ST7735_PIN_CS, ST7735_CS_DISABLE);
//
// At the End, set D7 - D0 direction to GPIO OutPut
//
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D7);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D6);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D5);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D4);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D3);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D2);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D1);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D0);
return ulData;
}
void main(void)
{
//unsigned long ulTmp = 0;
/********************** Configure System clock *************************/
SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ);
SysCtlDelay(TICK_SLOW);
// Configure LED(PC3) pin
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
xGPIOSPinTypeGPIOOutput(PC3);
// Turn off LED
GPIOPinClr(GPIOC_BASE, GPIO_PIN_3);
// Disable NVIC RTC interrupt
xIntDisable(xINT_RTC);
RTCDisable();
RTCIntCallbackInit(RTCHandler);
// Enable RTC second increment interrupt.
// Enable RTC minute interrupt.
RTCIntCfg( INT_SEC_EN | INT_MIN_DIS |
INT_HOUR_DIS | INT_DOM_DIS |
INT_DOW_DIS | INT_DOY_DIS |
INT_MON_DIS | INT_YEAR_DIS |
INT_ALARM_SEC_DIS | INT_ALARM_MIN_EN |
INT_ALARM_HOUR_DIS | INT_ALARM_DOM_DIS |
INT_ALARM_DOW_DIS | INT_ALARM_DOY_DIS |
INT_ALARM_MON_DIS | INT_ALARM_YEAR_DIS );
RTCTimeSet(RTC_TIMETYPE_SECOND, 0);
RTCTimeSet(RTC_TIMETYPE_MINUTE, 0);
RTCTimeSet(RTC_TIMETYPE_HOUR, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFWEEK, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFMONTH, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFYEAR, 0);
RTCTimeSet(RTC_TIMETYPE_MONTH, 0);
RTCTimeSet(RTC_TIMETYPE_YEAR, 0);
RTCAlarmSet(RTC_TIMETYPE_SECOND, 0);
RTCAlarmSet(RTC_TIMETYPE_MINUTE, 1);
RTCAlarmSet(RTC_TIMETYPE_HOUR, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFWEEK, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFMONTH, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFYEAR, 0);
RTCAlarmSet(RTC_TIMETYPE_MONTH, 0);
RTCAlarmSet(RTC_TIMETYPE_YEAR, 0);
RTCEnable();
RTCCounterReset();
xIntEnable(xINT_RTC);
while (1)
{
; // DoNothing
}
}
void SendData74HC595(unsigned char ucData)
{
unsigned long i = 0;
unsigned long ulBit = 0;
xGPIOSPinTypeGPIOOutput(sD4);
xGPIOSPinTypeGPIOOutput(sD8);
xGPIOSPinTypeGPIOOutput(sD7);
//
// 74HC595 operation
// Output Enable
//
xGPIOSPinWrite(sD7, 1);
xGPIOSPinWrite(sD7, 0);
//
// Send Data 0xF7 to 74HC595
//
xGPIOSPinWrite(sD4, 0);
for(i=0; i<8; i++)
{
if((ucData & (1<<i)))
{
xGPIOSPinWrite(sD8, 1);
}
else
{
xGPIOSPinWrite(sD8, 0);
}
xGPIOSPinWrite(sD4, 1);
xSysCtlDelay(1);
xGPIOSPinWrite(sD4, 0);
}
//
// Latch Data to 74HC595
//
xGPIOSPinWrite(sD12, 0);
xSysCtlDelay(1);
xGPIOSPinWrite(sD12, 1);
xSysCtlDelay(1);
xGPIOSPinWrite(sD12, 0);
}
//*****************************************************************************
//
//! \brief Init GPIO of the sensor shield board.
//!
//! \param None.
//!
//! Init GPIO of the sensor shield board.
//!
//! \return None
//
//*****************************************************************************
void
SensorShieldIOInit(void)
{
#if(SENSOR_SHIELD_OUT_USED > 0)
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O0);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O1);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O2);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O3);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O4);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O5);
xGPIOSPinWrite(SENSOR_SHIELD_O5, 1);
#endif
#if(SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG)
sA0PinTypeADC();
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A0);
#endif
#if(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG)
sA1PinTypeADC();
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A1);
#endif
#if(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG)
sA2PinTypeADC();
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A2);
#endif
#if(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG)
sA3PinTypeADC();
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A3);
#endif
#if(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG)
sA4PinTypeADC();
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A4);
#endif
#if(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG)
sA5PinTypeADC();
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A5);
#endif
#if(SENSOR_SHIELD_I2C_USED > 0)
sPinTypeI2C(sI2C_BASE);
#endif
#if(SENSOR_SHIELD_UART_USED > 0)
sPinTypeUART(sUART_BASE);
#endif
}
void WDT_Example_Reset(void)
{
unsigned long i = 0;
/********************** Configure System clock *************************/
SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ);
SysCtlDelay(TICK_SLOW);
// Power WDT/GPIO on
// Note: For LPC17xx, Watchdog module is always enabled.
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
// Configure LED pin PC3
xGPIOSPinTypeGPIOOutput(PC3);
// Reset source is watchdog ?
if(xtrue == WDTStatusFlagCheck(WDT_FLAG_TIMEOUT)) // Watchdog has reset mcu
{
// Clear Watchdog timeout flag
WDTStatusFlagClear(WDT_FLAG_TIMEOUT);
// Turn off the LED
GPIOPinClr(GPIOC_BASE, GPIO_PIN_3);
while(1);
} // First configure watchdog
else
{
// Configure watchdog into reset mode.
WDTCfg(WDT_CFG_RESET_MODE | WDT_CFG_CLKSRC_IRC, 0xFFFFF);
WDTEnable();
// Feed Watchdog and blink LED 50 times.
for(i = 0; i < 50; i++)
{
WDTFeed();
// LED ON
GPIOPinClr(GPIOC_BASE, GPIO_PIN_3);
SysCtlDelay(20*TICK_SLOW);
// LED OFF
GPIOPinSet(GPIOC_BASE, GPIO_PIN_3);
SysCtlDelay(20*TICK_SLOW);
}
// Stop Feed watchdog and wait for mcu reset.
while(1);
}
}
void main(void)
{
unsigned long Status = 0;
/********************** Configure System clock *************************/
SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ);
SysCtlDelay(TICK_SLOW);
// Enable LED PORT
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
// Configure LED(PC3) pin into output mode.
xGPIOSPinTypeGPIOOutput(PC3);
// Configure Timer Capture pin(PB26)
GPIOPinFunCfg(GPIOB_BASE, GPIO_PIN_26, GPIO_PB26_TIMCCP0);
TimerCounterCfg(TIMER0_BASE, TIMER_CFG_CNT_CAP0_BOTH);
TimerReset(TIMER0_BASE);
TimerStart(TIMER0_BASE);
while (1)
{
if( (TimerValueGet(TIMER0_BASE) % 10) == 0)
{
if(Status)
{
// Turn on LED
Status = 0;
GPIOPinSet(GPIOC_BASE, GPIO_PIN_3);
}
else
{
// Turn off LED
Status = 1;
GPIOPinClr(GPIOC_BASE, GPIO_PIN_3);
}
}
}
while(1);
}
int main()
{
unsigned long i;
unsigned char ucRet = 0;
unsigned long ulValueLength;
unsigned long ulData[10];
xPWMotorControl();
HD44780Init();
//
// Enable Peripheral SPI0
//
xSysCtlPeripheralEnable(SYSCTL_PERIPH_ADC);
xSPinTypeADC(ADC0, sA0);
//
// ADC Channel0 convert once, Software tirgger.
//
xADCConfigure(xADC0_BASE, xADC_MODE_SCAN_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
//
// Enable the channel0
//
xADCStepConfigure(xADC0_BASE, 0, xADC_CTL_CH0);
//
// Enable the ADC end of conversion interrupt
//
//xADCIntEnable(xADC0_BASE, xADC_INT_END_CONVERSION);
//
// install the call back interrupt
//
//xADCIntCallbackInit(xADC0_BASE, ADCCallback);
//
// Enable the NVIC ADC interrupt
//
//xIntEnable(xINT_ADC0);
//
// Enable the adc
//
xADCEnable(xADC0_BASE);
//
// start ADC convert
//
xADCProcessorTrigger( xADC0_BASE );
HD44780LocationSet(0, 0);
HD44780DisplayString("Hello Nuvoton!");
HD44780LocationSet(0, 1);
HD44780DisplayString("Hello CooCox! ");
SysCtlDelay(10000000);
while(1)
{
SysCtlDelay(1000000);
//
// Read the convert value
//
ulValueLength = xADCDataGet(xADC0_BASE, ulData);
if (ulData[0] < 0x30100)
{
HD44780DisplayClear();
HD44780LocationSet(0, 0);
HD44780DisplayString("right");
SendData74HC595(0x60);
sD11PinTypePWM();
xPWMStart(xPWMB_BASE, xPWM_CHANNEL7);
xGPIOSPinWrite(sD3, 1);
}
else if(ulData[0] < 0x30300)
{
HD44780DisplayClear();
HD44780LocationSet(0, 0);
HD44780DisplayString("up");
ulDuty++;
xPWMDutySet(xPWMB_BASE, xPWM_CHANNEL7, ulDuty);
sD11PinTypePWM();
xPWMStart(xPWMB_BASE, xPWM_CHANNEL7);
xGPIOSPinWrite(sD3, 1);
SysCtlDelay(100000);
}
else if(ulData[0] < 0x30600)
{
HD44780DisplayClear();
HD44780LocationSet(0, 0);
HD44780DisplayString("dowm");
ulDuty--;
xPWMDutySet(xPWMB_BASE, xPWM_CHANNEL7, ulDuty);
sD11PinTypePWM();
xPWMStart(xPWMB_BASE, xPWM_CHANNEL7);
xGPIOSPinWrite(sD3, 1);
SysCtlDelay(100000);
}
else if(ulData[0] < 0x30900)
{
HD44780DisplayClear();
HD44780LocationSet(0, 0);
HD44780DisplayString("left");
SendData74HC595(0x18);
sD11PinTypePWM();
xPWMStart(xPWMB_BASE, xPWM_CHANNEL7);
xGPIOSPinWrite(sD3, 1);
}
else if(ulData[0] < 0x30E00)
{
HD44780DisplayClear();
HD44780LocationSet(0, 0);
HD44780DisplayString("select");
SendData74HC595(0x60);
sD11PinTypePWM();
xPWMStart(xPWMB_BASE, xPWM_CHANNEL7);
xGPIOSPinWrite(sD3, 1);
}
else
{
HD44780DisplayClear();
HD44780LocationSet(0, 0);
HD44780DisplayString("Nothing");
xPWMStop(xPWMB_BASE, xPWM_CHANNEL7);
xGPIOSPinTypeGPIOOutput(sD11);
xGPIOSPinTypeGPIOOutput(sD3);
xGPIOSPinWrite(sD11, 0);
xGPIOSPinWrite(sD3, 0);
}
if(ulDuty >= 99)
{
ulDuty = 99;
}
if(ulDuty <= 1)
{
ulDuty = 1;
}
}
//
// SD Card Init
//
ucRet = SDInit();
//
// write a block to the card
//
ucRet = SDBlockWrite(pucBuf, 0);
//
// Re-init the test buffer to 0
//
for(i = 0; i < 512; i++)
{
pucBuf[i] = 0;
}
//
// Read 1 block from the card
//
ucRet = SDBlockRead(pucBuf, 0);
while(1);
}
//*****************************************************************************
//
//! \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 ST7735 LCD Device.
//!
//! \param None.
//!
//! This function is used to Init the ST7735 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 ST7735 Initial state can be determined by the \ref ST7735_Config.
//! - Pins that used is determined by \ref ST7735_Config_Pins.
//! - The LCD display line is determined by \ref ST7735_DISPLAY_LINE.
//! - The LCD character font is determined by \ref ST7735_CHARACTER_FONT.
//! .
//!
//! \return None.
//
//*****************************************************************************
void
ST7735Init(void)
{
unsigned long ulCount;
//
// Enable GPIO Port that used
//
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_D7));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_D6));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_D5));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_D4));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_D3));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_D2));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_D1));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_D0));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_RD));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_WR));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_CS));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_RS));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_RST));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(ST7735_PIN_BACKLIGHT));
//
// Set Pins Type to GPIO Output
//
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D7);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D6);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D5);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D4);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D3);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D2);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D1);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_D0);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_RD);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_WR);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_CS);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_RS);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_RST);
xGPIOSPinTypeGPIOOutput(ST7735_PIN_BACKLIGHT);
//
// Turn on the backlight.
//
xGPIOSPinWrite(ST7735_PIN_BACKLIGHT, ST7735_BACKLIGHT_ON);
xGPIOSPinWrite(ST7735_PIN_RST, ST7735_RST_ENABLE);
xSysCtlDelay(100);
xGPIOSPinWrite(ST7735_PIN_RST, ST7735_RST_DISABLE);
xSysCtlDelay(100);
ST7735WriteCmd(ST7735_SLPOUT_REG); //sleep out and booter on
xSysCtlDelay(5000);
ST7735WriteCmd(ST7735_FRMCTR1_REG); //
ST7735WriteData(0x12C);
ST7735WriteData(0x2D00);
ST7735WriteCmd(ST7735_FRMCTR2_REG); //
ST7735WriteData(0x12C);
ST7735WriteData(0x2D00);
ST7735WriteCmd(ST7735_FRMCTR3_REG); //
ST7735WriteData(0x12C);
ST7735WriteData(0x2D01);
ST7735WriteData(0x2C2D);
ST7735WriteCmd(ST7735_INVCTR_REG); //
ST7735WriteData(0x07);
//============ power control setting ==========================
ST7735WriteCmd(ST7735_PWCTR1_REG); //
ST7735WriteData(0xA202);
ST7735WriteData(0x84);
ST7735WriteCmd(ST7735_PWCTR2_REG); // set VCL,VGH,VGL,AVDD
ST7735WriteData(0xC5);
ST7735WriteCmd(ST7735_PWCTR3_REG); //
ST7735WriteData(0x0A00);
ST7735WriteCmd(ST7735_PWCTR4_REG); //
ST7735WriteData(0x8A2A);
ST7735WriteCmd(ST7735_PWCTR5_REG); //
ST7735WriteData(0x8AEE);
ST7735WriteCmd(ST7735_VMCTR1_REG); //
ST7735WriteData(0x0E);
ST7735WriteCmd(ST7735_MADCTL_REG); //set VCOMH,VCOML voltage
ST7735WriteData(0xC8); //VCOMH=3.275V
ST7735WriteCmd(ST7735_INVOFF_REG);
ST7735WriteCmd(ST7735_INVON_REG);
//===== gamma"+"polarity correction characteristic setting ===================
ST7735WriteCmd(ST7735_GAMCTRP1_REG);
ST7735WriteData(0x21C);
ST7735WriteData(0x712);
ST7735WriteData(0x3732);
ST7735WriteData(0x292D);
ST7735WriteData(0x2925);
ST7735WriteData(0x2B39);
ST7735WriteData(0x1);
ST7735WriteData(0x310);
//===== gamma"-"polarity correction characteristic setting ===================
ST7735WriteCmd(ST7735_GAMCTRN1_REG);
ST7735WriteData(0x31D);
ST7735WriteData(0x706);
ST7735WriteData(0x2E2C);
ST7735WriteData(0x292D);
ST7735WriteData(0x2E2E);
ST7735WriteData(0x373F);
ST7735WriteData(0x0);
ST7735WriteData(0x210);
ST7735WriteCmd(ST7735_INVOFF_REG); //
ST7735WriteCmd(ST7735_MADCTL_REG); // memory access control
write_data(0xcc);
ST7735WriteCmd(ST7735_COLMOD_REG); // E0H or E1 Register enable or disabl
write_data(0x05); // E0H or E1 Register enable
ST7735WriteCmd(ST7735_DISPON_REG); // display on
//
// Set the display size and ensure that the GRAM window is set to allow
// access to the full display buffer.
//
ST7735WriteCmd(ST7735_CASET_REG);
ST7735WriteData(0);
ST7735WriteData(LCD_HORIZONTAL_MAX - 1);
ST7735WriteCmd(ST7735_RASET_REG);
ST7735WriteData(0);
ST7735WriteData(LCD_VERTICAL_MAX - 1);
//
// Clear the contents of the display buffer.
//
ST7735WriteCmd(ST7735_RAMWR_REG);
for(ulCount = 0; ulCount < (LCD_HORIZONTAL_MAX * LCD_VERTICAL_MAX); ulCount++)
{
ST7735WriteData(0xFFFF);
}
}
//*****************************************************************************
//
//! \brief Init the sensor shield board.
//!
//! \param None.
//!
//! Init the sensor shield board.
//!
//! \return None
//
//*****************************************************************************
void
SensorShieldInit(void)
{
#if(SENSOR_SHIELD_OUT_USED > 0)
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O0);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O1);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O2);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O3);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O4);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O5);
#endif
#if((SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG))
xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_HCLK, 3);
//
// Enable Peripheral ADC0
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_ADC0);
//
// Configure Some GPIO pins as ADC Mode
//
//
// Enable the adc
//
xADCEnable(xADC0_BASE);
//
// ADC Channel0 convert once, Software tirgger.
//
xADCConfigure(xADC0_BASE, xADC_MODE_SCAN_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
//
// Enable the channel0
//
//
// Set Compare Condition(Moisture Sensor Limited Value)
//
xADCCompConditionConfig(ADC_BASE, 0, xADC_COMP_INT_LOW);
ADCCompDataSet(ADC_BASE, 0, 1600, 1);
xADCCompEnable(ADC_BASE, 0);
//
// Enable the ADC end of conversion interrupt
//
xADCIntEnable(xADC0_BASE, xADC_INT_COMP);
//
// install the call back interrupt
//
xADCIntCallbackInit(xADC0_BASE, ADCCallback);
//
// Enable the NVIC ADC interrupt
//
xIntEnable(xINT_ADC0);
xADCProcessorTrigger(xADC0_BASE);
#endif
#if(SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG)
sA0PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH0);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A0);
#endif
#if(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG)
sA1PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH1);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A1);
#endif
#if(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG)
sA2PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH2);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A2);
#endif
#if(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG)
sA3PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH3);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A3);
#endif
#if(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG)
sA4PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH4);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A4);
#endif
#if(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG)
sA5PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH5);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A5);
#endif
#if(SENSOR_SHIELD_I2C_USED > 0)
//
// Enable the GPIOx port which is connected with I2C
//
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_TWI_SDA));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_TWI_SCK));
//
// Enable the I2Cx which is connected with device
//
xSysCtlPeripheralEnable2(sI2C_BASE);
//
// Set BH1750_PIN_I2C_CLK as CLK
//
sPinTypeI2C(sI2C_BASE);
//
// Configure MCU as a master device and Set Clcok Rates
//
xI2CMasterInit(sI2C_BASE, 100000);
xI2CMasterEnable(sI2C_BASE);
#endif
#if(SENSOR_SHIELD_UART_USED > 0)
xSysCtlPeripheralEnable2(sUART_BASE);
xSysCtlPeripheralClockSourceSet(xSYSCTL_UART1_MAIN, 1);
sPinTypeUART(sUART_BASE);
xUARTConfigSet(sUART_BASE, 115200, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
#endif
}
//*****************************************************************************
//
//! \brief Initialize the sensor shield board.
//!
//! \param None.
//!
//! Initialize the sensor shield board.
//!
//! \return None
//
//*****************************************************************************
void
SensorShieldInit(void)
{
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O0));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O1));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O2));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O3));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O4));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O5));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I0));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I1));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I2));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I3));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I4));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I5));
#if(SENSOR_SHIELD_OUT_USED > 0)
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O0);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O1);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O2);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O3);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O4);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O5);
//xSysCtlPeripheralEnable2();
#endif
#if((SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG))
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(sD45));
//
// Set ADCCLK prescaler, ADCCLK=PCLK2(max 72MHz)/Div(Div:2,4,6,8)
// You should set ADCCLK < 14MHz to ensure the accuracy of ADC
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_MAIN, 8);
//
// Enable Peripheral ADC clock
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_ADC1);
//
// Enable the ADC conversion
//
xADCEnable(sADC_BASE);
//
// The two sentences below configure ADC to scan mode, continuous convert, software trigger.
//
xADCConfigure(sADC_BASE, xADC_MODE_SCAN_SINGLE_CYCLE, ADC_TRIGGER_PROCESSOR);
xADCConfigure(sADC_BASE, xADC_MODE_SCAN_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
//
// Configure channel step by step.(Max 4 steps, the 2nd parameter start from 0, max is 3)
// Must not jump over a step, or the ADC result may be in wrong position.
//
xADCStepConfigure(sADC_BASE, 0, sADC_CH0);
xADCStepConfigure(sADC_BASE, 1, sADC_CH1);
xADCStepConfigure(sADC_BASE, 2, sADC_CH2);
xADCStepConfigure(sADC_BASE, 3, sADC_CH3);
#endif
#if(SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG)
sA0PinTypeADC();
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I0);
#endif
#if(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG)
sA1PinTypeADC();
#elif (SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I1);
#endif
#if(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG)
sA2PinTypeADC();
#elif (SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I2);
#endif
#if(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG)
sA3PinTypeADC();
#elif (SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I3);
#endif
#if(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG)|| \
(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I4);
#endif
#if(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG)|| \
(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I5);
#endif
#if(SENSOR_SHIELD_I2C_USED > 0)
//
// Enable the GPIOx port which is connected with I2C
//
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_TWI_SDA));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_TWI_SCK));
//
// Enable the I2Cx which is connected with device
//
xSysCtlPeripheralEnable2(sI2C_BASE);
//
// Set BH1750_PIN_I2C_CLK as CLK
//
sPinTypeI2C(sI2C_BASE);
//
// Configure MCU as a master device and Set Clcok Rates
//
xI2CMasterInit(sI2C_BASE, 100000);
xI2CMasterEnable(sI2C_BASE);
#endif
#if(SENSOR_SHIELD_UART_USED > 0)
xSysCtlPeripheralEnable2(sUART_BASE);
// xSysCtlPeripheralClockSourceSet(xSYSCTL_UART1_MAIN, 1);
sPinTypeUART(sUART_BASE);
xUARTConfigSet(sUART_BASE, 115200, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
#endif
}
