/* Initialize the SPI */
void Chip_SPI_IF_Init(LPC_SPI_T *pSPI, SPI_MODECONFIG_T *pConfig)
{
uint32_t EnStat;
Chip_SPI_Init(pSPI);
EnStat = pSPI->CFG & SPI_CFG_SPI_EN;
/* Disable before update CFG register */
if (EnStat) {
Chip_SPI_Disable(pSPI);
}
/* SPI Configurate */
pSPI->CFG = ((uint32_t) pConfig->ClockMode) | ((uint32_t) pConfig->DataOrder) | ((uint32_t) pConfig->Mode) |
((uint32_t) pConfig->SSELPol);
if ( pConfig->Mode == SPI_CFG_MASTER_EN ) {
/* Rate Divider setting */
pSPI->DIV = SPI_DIV_VAL(pConfig->ClkDiv);
}
/* Clear status flag*/
Chip_SPI_ClearStatus(pSPI, SPI_STAT_RXOV | SPI_STAT_TXUR | SPI_STAT_SSA | SPI_STAT_SSD);
/* Return the previous state */
if (EnStat) {
Chip_SPI_Enable(pSPI);
}
}
/* Setup SPI handle and parameters */
static void setupSpiMaster()
{
SPI_CFG_T spiCfg;
SPI_DELAY_CONFIG_T spiDelayCfg;
/* Initialize SPI Block */
Chip_SPI_Init(LPC_SPI0);
/* Set SPI Config register */
spiCfg.ClkDiv = 0xFFFF; /* Set Clock divider to maximum */
spiCfg.Mode = SPI_MODE_MASTER; /* Enable Master Mode */
spiCfg.ClockMode = SPI_CLOCK_MODE0; /* Enable Mode 0 */
spiCfg.DataOrder = SPI_DATA_MSB_FIRST; /* Transmit MSB first */
/* Slave select polarity is active low */
spiCfg.SSELPol = (SPI_CFG_SPOL0_LO | SPI_CFG_SPOL1_LO | SPI_CFG_SPOL2_LO | SPI_CFG_SPOL3_LO);
Chip_SPI_SetConfig(LPC_SPI0, &spiCfg);
/* Set Delay register */
spiDelayCfg.PreDelay = 2;
spiDelayCfg.PostDelay = 2;
spiDelayCfg.FrameDelay = 2;
spiDelayCfg.TransferDelay = 2;
Chip_SPI_DelayConfig(LPC_SPI0, &spiDelayCfg);
/* Enable Loopback mode for this example */
Chip_SPI_EnableLoopBack(LPC_SPI0);
/* Enable SPI0 */
Chip_SPI_Enable(LPC_SPI0);
}
/* Initialize the SPI */
void Chip_SPI_Init(LPC_SPI_T *pSPI, SPI_CONFIG_T *pConfig)
{
uint32_t EnStat = pSPI->CFG & SPI_CFG_SPI_EN;
Chip_Clock_EnablePeriphClock((pSPI == LPC_SPI1) ? SYSCTL_CLOCK_SPI1 : SYSCTL_CLOCK_SPI0);
Chip_SYSCTL_PeriphReset((pSPI == LPC_SPI1) ? RESET_SPI1 : RESET_SPI0);
/* Disable before update CFG register */
if (EnStat) {
Chip_SPI_Disable(pSPI);
}
/* SPI Configurate */
pSPI->CFG = ((uint32_t) pConfig->ClockMode) | ((uint32_t) pConfig->DataOrder) | ((uint32_t) pConfig->Mode) |
((uint32_t) pConfig->SSELPol);
/* Rate Divider setting */
pSPI->DIV = SPI_DIV_VAL(pConfig->ClkDiv);
/* Clear status flag*/
Chip_SPI_ClearStatus(pSPI, SPI_STAT_CLR_RXOV | SPI_STAT_CLR_TXUR | SPI_STAT_CLR_SSA | SPI_STAT_CLR_SSD);
/* Return the previous state */
if (EnStat) {
Chip_SPI_Enable(pSPI);
}
}
uint32_t SPI_ReadCh0(void){
/* Disable clocks to SWM and IOCON to save power */
Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_SWM);
Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_IOCON);
// initialize pins
Chip_SWM_DisableFixedPin(SWM_FIXED_XTALIN);
Chip_SWM_MovablePinAssign(SWM_SPI1_SCK_IO, 8);
Chip_SWM_MovablePinAssign(SWM_SPI1_MOSI_IO, 17);
Chip_SWM_MovablePinAssign(SWM_SPI1_MISO_IO, 16);
//TODO: do we need to set slave select if it's tied to ground?
Chip_SWM_MovablePinAssign(SWM_SPI1_SSEL_IO, 4);
ConfigStruct.Mode = SPI_MODE_MASTER;
ConfigStruct.ClkDiv = Chip_SPI_CalClkRateDivider(LPC_SPI1, 100000);
ConfigStruct.ClockMode = SPI_CLOCK_CPHA0_CPOL0;
ConfigStruct.DataOrder = SPI_DATA_MSB_FIRST; //enable MSB first option
ConfigStruct.SSELPol = SPI_CFG_SPOL_LO;
Chip_SPI_Init(LPC_SPI1, &ConfigStruct);
DelayConfigStruct.FrameDelay = 0;
DelayConfigStruct.PostDelay = 0;
DelayConfigStruct.PreDelay = 0;
DelayConfigStruct.TransferDelay = 0;
Chip_SPI_DelayConfig(LPC_SPI1, &DelayConfigStruct);
Chip_SPI_Enable(LPC_SPI1);
//Chip_SPI_EnableLoopBack(LPC_SPI1);
// init transmit buffer
TxBuf[0] = 0x68;
TxBuf[1] = 0x00;
XfSetup.Length = BUFFER_SIZE;
XfSetup.pTx = TxBuf;
XfSetup.RxCnt = XfSetup.TxCnt = 0;
XfSetup.DataSize = 8;
XfSetup.pRx = RxBuf;
Chip_SPI_RWFrames_Blocking(LPC_SPI1, &XfSetup);
uint16_t value = ((RxBuf[0] & 0x03) << 8) + (RxBuf[1] & 0xFF);
//Chip_SPI_DisableLoopBack(LPC_SPI1);
/* DeInitialize SPI peripheral */
Chip_SPI_DeInit(LPC_SPI1);
/* Disable clocks to SWM and IOCON to save power */
Chip_Clock_DisablePeriphClock(SYSCTL_CLOCK_SWM);
Chip_Clock_DisablePeriphClock(SYSCTL_CLOCK_IOCON);
return value;
}
int32_t main(void) {
int32_t i,cnt=0;
uint8_t RC5_System_prev=0;
uint8_t RC5_Command_prev=0;
CHIP_PMU_MCUPOWER_T mcupower=PMU_MCU_SLEEP;
SystemCoreClockUpdate();
// init GPIO
Chip_GPIO_Init(LPC_GPIO_PORT);
Chip_SYSCTL_PeriphReset(RESET_GPIO);
// init SPI0 at SystemCoreClock speed
Chip_SPI_Init(LPC_SPI0);
Chip_SPI_ConfigureSPI(LPC_SPI0,SPI_MODE_MASTER|
SPI_CLOCK_CPHA0_CPOL0|
SPI_DATA_MSB_FIRST|
SPI_SSEL_ACTIVE_LO);
LPC_SPI0->DIV=0;
Chip_SPI_Enable(LPC_SPI0);
// init MRT
Chip_MRT_Init();
// init SWM
Chip_SWM_Init();
Chip_SWM_DisableFixedPin(SWM_FIXED_SWCLK);//PIO0_3
Chip_SWM_DisableFixedPin(SWM_FIXED_SWDIO);//PIO0_2
Chip_SWM_DisableFixedPin(SWM_FIXED_ACMP_I2);//PIO0_1
Chip_SWM_DisableFixedPin(SWM_FIXED_ACMP_I1);//PIO0_0
Chip_SWM_MovablePinAssign(SWM_SPI0_SCK_IO,CLK_PIN);
Chip_SWM_MovablePinAssign(SWM_SPI0_MOSI_IO,MOSI_PIN);
Chip_SWM_MovablePinAssign(SWM_CTIN_0_I,IR_PIN);
Chip_SWM_Deinit();
// init onboard LED
Chip_GPIO_SetPinState(LPC_GPIO_PORT,0,LED_PIN,true);
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT,0,LED_PIN);
// init LCD reset pin
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT,0,RESET_PIN);
// init LCD
LCDInit();
LCDClearScreenBlack();
// init SCT
Chip_SCT_Init(LPC_SCT);
// set prescaler, SCT clock = 1 MHz, clear counter
LPC_SCT->CTRL_L |= SCT_CTRL_PRE_L(SystemCoreClock/1000000-1) | SCT_CTRL_CLRCTR_L;
sct_fsm_init();
NVIC_EnableIRQ(SCT_IRQn);
// init PIO0_3 pin interrupt for wakeup from sleep mode
Chip_SYSCTL_SetPinInterrupt(IR_IRQ,IR_PIN);
Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(IR_IRQ));
NVIC_EnableIRQ(PININT3_IRQn);
Chip_SYSCTL_EnablePINTWakeup(IR_IRQ);
// set sleep options
Chip_SYSCTL_SetDeepSleepPD(SYSCTL_DEEPSLP_BOD_PD | SYSCTL_DEEPSLP_WDTOSC_PD);
Chip_SYSCTL_SetWakeup(~(SYSCTL_SLPWAKE_IRCOUT_PD | SYSCTL_SLPWAKE_IRC_PD | SYSCTL_SLPWAKE_FLASH_PD ));
LCDPutStr("kbiva.wordpress.com", MAX_X / 2 + 50, 10, WHITE, BLACK);
LCDPutStr("RC5 Decoder", MAX_X / 2 + 35, 35, WHITE, BLACK);
LCDPutStr("Frame:", MAX_X / 2 + 20, 1, WHITE, BLACK);
LCDPutStr("System:", MAX_X / 2 + 5 , 1, WHITE, BLACK);
LCDPutStr("Cmd:", MAX_X / 2 - 10, 1, WHITE, BLACK);
LCDPutStr("Toggle:", MAX_X / 2 - 25, 1, WHITE, BLACK);
LCDPutStr("Count:", MAX_X / 2 - 40, 1, WHITE, BLACK);
while (1) {
// put chip to sleep
switch(mcupower) {
case PMU_MCU_SLEEP:
default:
LCDPutStr("SLEEP ", MAX_X / 2 - 60, 10, WHITE, BLACK);
Chip_PMU_SleepState(LPC_PMU);
break;
case PMU_MCU_DEEP_SLEEP:
LCDPutStr("DEEP-SLEEP", MAX_X / 2 - 60, 10, WHITE, BLACK);
Chip_PMU_DeepSleepState(LPC_PMU);
break;
case PMU_MCU_POWER_DOWN:
LCDPutStr("POWER-DOWN", MAX_X / 2 - 60, 10, WHITE, BLACK);
Chip_PMU_PowerDownState(LPC_PMU);
break;
}
// start MRT timer channel 0
Chip_MRT_SetInterval(LPC_MRT_CH0, SystemCoreClock | MRT_INTVAL_LOAD);
Chip_MRT_SetMode(LPC_MRT_CH0,MRT_MODE_ONESHOT);
Chip_MRT_SetEnabled(LPC_MRT_CH0);
// turn on onboard LED
Chip_GPIO_SetPinState(LPC_GPIO_PORT,0,LED_PIN,false);
// start SCT
LPC_SCT->CTRL_L &= ~SCT_CTRL_HALT_L;
// wait for timeout
while(!RC5_timeout)
{};
// stop SCT
LPC_SCT->CTRL_L |= SCT_CTRL_HALT_L;
if (RC5_flag) {
// if frame received, output information on LCD
if((RC5_System != RC5_System_prev) || (RC5_Command != RC5_Command_prev)) {
cnt = 1;
}
else {
cnt++;
}
for (i = 3; i >= 0; i--){
LCDPutChar(ascii[(RC5_Frame >> (i * 4)) & 0x0F],MAX_X / 2 + 20,80+(3-i)*7,WHITE, BLACK);
if(i < 2) {
if((RC5_System!=RC5_System_prev) || (RC5_Command!=RC5_Command_prev)){
LCDPutChar(ascii[(RC5_System >> (i * 4)) & 0x0F],MAX_X / 2 + 5,66+(3-i)*7,WHITE, BLACK);
LCDPutChar(ascii[(RC5_Command >> (i * 4)) & 0x0F],MAX_X / 2 - 10,66+(3-i)*7,WHITE, BLACK);
}
}
LCDPutChar(ascii[(cnt >> (i * 4)) & 0x0F],MAX_X / 2 - 40,80+(3-i)*7,WHITE, BLACK);
}
LCDPutStr(RC5_Toggle ? "ON ":"OFF", MAX_X / 2 - 25, 80, WHITE, BLACK);
switch(RC5_Command) {
case 0x50:
mcupower = PMU_MCU_SLEEP;
break;
case 0x55:
if(RC5_Toggle){
spi0Transfer(SLEEPOUT);
spi0Transfer(DISPON);
}
else {
spi0Transfer(DISPOFF);
spi0Transfer(SLEEPIN);
}
break;
case 0x56:
mcupower = PMU_MCU_DEEP_SLEEP;
break;
case 0x6B:
mcupower = PMU_MCU_POWER_DOWN;
break;
}
RC5_System_prev = RC5_System;
RC5_Command_prev = RC5_Command;
}
// turn off onboard LED
Chip_GPIO_SetPinState(LPC_GPIO_PORT,0,LED_PIN,true);
// clear flags
RC5_flag = 0;
RC5_timeout = 0;
}
