/* Setup slave controller */
static void setupSlave(void)
{
/* Initialize SPI controller */
Chip_SPI_Init(LPC_SPISLAVEPORT);
/* Call to initialize first SPI controller for mode0, master mode, MSB first */
Chip_SPI_ConfigureSPI(LPC_SPISLAVEPORT, SPI_MODE_SLAVE |/* Enable slave mode */
SPI_CLOCK_CPHA0_CPOL0 | /* Set Clock polarity to 0 */
SPI_CFG_MSB_FIRST_EN |/* Enable MSB first option */
SPI_CFG_SPOL_LO); /* Chipselect is active low */
/* Initialize SPI controllers */
Chip_SPI_Init(LPC_SPISLAVEPORT);
/* Setup slave controller for 8-bit transfer. Sizes can be altered later
for each slave select in the slave select assertion callback once the
transfer starts if needed. The master slave transfer size is setup as
part of the master transfer description in the options field. */
Chip_SPI_SetXferSize(LPC_SPISLAVEPORT, 16);
/* For the SPI controller configured in slave mode, enable SPI slave interrupts
for interrupt service. Do not enable SPI_INTENSET_TXDYEN. */
Chip_SPI_EnableInts(LPC_SPISLAVEPORT, (SPI_INTENSET_RXDYEN |
SPI_INTENSET_RXOVEN | SPI_INTENSET_TXUREN | SPI_INTENSET_SSAEN |
SPI_INTENSET_SSDEN));
/* Setup slave transfer callbacks in the transfer descriptor */
spiSlaveXfer.pCB = &spiSlaveCallbacks;
}
/* Setup master controller */
static void setupMaster(void)
{
SPIM_DELAY_CONFIG_T masterDelay;
/* Initialize SPI controller */
Chip_SPI_Init(LPC_SPIMASTERPORT);
/* Call to initialize first SPI controller for mode0, master mode, MSB first */
Chip_SPI_ConfigureSPI(LPC_SPIMASTERPORT, SPI_MODE_MASTER | /* Enable master mode */
SPI_CLOCK_CPHA0_CPOL0 | /* Set Clock polarity to 0 */
SPI_CFG_MSB_FIRST_EN |/* Enable MSB first option */
SPI_CFG_SPOL_LO); /* Chipselect is active low */
/* Setup master clock rate, slave clock doesn't need to be setup */
Chip_SPIM_SetClockRate(LPC_SPIMASTERPORT, LPCMASTERCLOCKRATE);
/* Setup master delay (all chip selects) */
masterDelay.PreDelay = 0xD;
masterDelay.PostDelay = 0xD;
masterDelay.FrameDelay = 0xD;
masterDelay.TransferDelay = 0xD;
Chip_SPIM_DelayConfig(LPC_SPIMASTERPORT, &masterDelay);
/* For the SPI controller configured in master mode, enable SPI master interrupts
for interrupt service. Do not enable SPI_INTENSET_TXDYEN. */
Chip_SPI_EnableInts(LPC_SPIMASTERPORT, (SPI_INTENSET_RXDYEN |
SPI_INTENSET_RXOVEN | SPI_INTENSET_TXUREN | SPI_INTENSET_SSAEN |
SPI_INTENSET_SSDEN));
/* Setup master transfer callbacks in the transfer descriptor */
spiMasterXfer.pCB = &spiMasterCallbacks;
}
/* 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);
}
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;
}
int main(void) {
char str_buffer[16];
SystemCoreClockUpdate();
gpioInit();
interruptInit();
adcInit();
Chip_PMU_GetSleepFlags(LPC_PMU);
Chip_PMU_ClearSleepFlags(LPC_PMU, PMU_PCON_DPDFLAG);
Chip_SPI_Init(SPI_PORT);
SysTick_Config(Chip_Clock_GetSystemClockRate() / TICKRATE_HZ);
//StuckI2CHack();
delayms(10);
MoonLander_I2C_Init(SENSOR_I2C, MOONLANDER_I2C_100K);
delayms(100);
// Initialize sensors:
HTU21D_Init(&g_HTU21D, SENSOR_I2C);
delayms(10);
HMC5883L_Init(&g_HMC5883L, SENSOR_I2C);
delayms(10);
HMC5883L_SetRange(&g_HMC5883L, HMC5883L_RANGE_2_5);
eGFX_InitDriver();
C12832A_Init(&g_C12832A, SPI_PORT, LCD_A0_PIN, LCD_RST_PIN, LCD_SSEL);
delayms(10);
Plot_Init(&g_plot_temp, -10, 40, "Temp (C)", 0);
Plot_Init(&g_plot_rh, 0, 100, "RH", 0);
Plot_Init(&g_plot_mag, -400, 300, "uTesla", 1);
Plot_SetSpecialValue(&g_plot_mag, 9000, "OL");
Compass_Init(&g_compass);
g_left_display = DISPLAY_TEMP;
g_right_display = DISPLAY_COMPASS;
// Straight to sleep on boot:
g_go_to_sleep = 1;
// Or not:
//g_go_to_sleep = 0;
//wakeup();
while(1) {
fillScreen(0x0);
if (g_go_to_sleep) {
// Write the empty back buffer to the screen:
eGFX_Dump(&eGFX_BackBuffer, &g_C12832A);
g_ignore_switches = 1;
// Sleep!
goToSleep();
// Processor has been woken up, restart clocks, etc.:
wakeup();
delayms(SW_DEBOUNCE_MS);
g_ignore_switches = 0;
}
switch (g_left_display) {
case DISPLAY_TEMP:
Plot_Draw(&eGFX_BackBuffer, &g_plot_temp, PLOT_LEFT);
break;
case DISPLAY_RH:
Plot_Draw(&eGFX_BackBuffer, &g_plot_rh, PLOT_LEFT);
break;
case DISPLAY_MAG:
Plot_Draw(&eGFX_BackBuffer, &g_plot_mag, PLOT_LEFT);
break;
case DISPLAY_COMPASS:
Compass_Draw(&eGFX_BackBuffer, &g_compass, COMPASS_LEFT);
break;
case DISPLAY_RANGE:
eGFX_DrawString(&eGFX_BackBuffer, "Range", 24, 1, &FONT_3_5_1BPP);
sprintf(str_buffer, "%0.2f cm", getRangeCentimeters());
eGFX_DrawString(&eGFX_BackBuffer, str_buffer, 24, 13, &FONT_3_5_1BPP);
break;
default:
break;
}
switch (g_right_display) {
case DISPLAY_TEMP:
Plot_Draw(&eGFX_BackBuffer, &g_plot_temp, PLOT_RIGHT);
break;
case DISPLAY_RH:
Plot_Draw(&eGFX_BackBuffer, &g_plot_rh, PLOT_RIGHT);
break;
case DISPLAY_MAG:
Plot_Draw(&eGFX_BackBuffer, &g_plot_mag, PLOT_RIGHT);
break;
case DISPLAY_COMPASS:
Compass_Draw(&eGFX_BackBuffer, &g_compass, COMPASS_RIGHT);
break;
case DISPLAY_RANGE:
eGFX_DrawString(&eGFX_BackBuffer, "Range", 88, 1, &FONT_3_5_1BPP);
sprintf(str_buffer, "%0.2f cm", getRangeCentimeters());
eGFX_DrawString(&eGFX_BackBuffer, str_buffer, 88, 13, &FONT_3_5_1BPP);
break;
default:
break;
}
eGFX_Dump(&eGFX_BackBuffer, &g_C12832A);
}
return 0 ;
}
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;
}