bool spi_init(struct spi_bus *bus)
{
#ifdef DEBUG_LED
/* Grab a debug LED for testing. */
pin_enable(DEBUG_LED);
pin_reset(DEBUG_LED);
pin_set_mode(DEBUG_LED, PIN_MODE_OUTPUT);
pin_set_otype(DEBUG_LED, PIN_TYPE_PUSHPULL);
pin_set_ospeed(DEBUG_LED, PIN_SPEED_2MHZ);
#endif
#ifdef ERROR_LED
pin_enable(ERROR_LED);
pin_reset(ERROR_LED);
pin_set_mode(ERROR_LED, PIN_MODE_OUTPUT);
pin_set_otype(ERROR_LED, PIN_TYPE_PUSHPULL);
pin_set_ospeed(ERROR_LED, PIN_SPEED_2MHZ);
#endif
rcc_enable(bus->rcc_dev);
/* Configure GPIO pins for SPI operation. */
pin_enable(bus->miso_pin);
pin_set_af(bus->miso_pin, bus->af);
pin_set_mode(bus->miso_pin, PIN_MODE_AF);
pin_set_pupd(bus->miso_pin, PIN_PUPD_NONE);
pin_enable(bus->mosi_pin);
pin_set_af(bus->mosi_pin, bus->af);
pin_set_mode(bus->mosi_pin, PIN_MODE_AF);
pin_set_otype(bus->mosi_pin, PIN_TYPE_PUSHPULL);
pin_enable(bus->sck_pin);
pin_set_af(bus->sck_pin, bus->af);
pin_set_mode(bus->sck_pin, PIN_MODE_AF);
pin_set_otype(bus->sck_pin, PIN_TYPE_PUSHPULL);
bus->lock = xSemaphoreCreateMutex();
if (bus->lock == NULL)
goto fail;
vSemaphoreCreateBinary(bus->complete);
if (bus->complete == NULL)
goto fail;
/* Take the semaphore initially so we will block next time. */
xSemaphoreTake(bus->complete, portMAX_DELAY);
interrupt_set_priority(bus->irq, INTERRUPT_PRIORITY_FREERTOS_SAFE);
return true;
fail:
if (bus->lock != NULL)
vSemaphoreDelete(bus->lock);
if (bus->complete != NULL)
vSemaphoreDelete(bus->complete);
return false;
}
static void led_pin_setup(struct pin *pin) {
pin_enable(pin);
pin_set_mode(pin, PIN_MODE_OUTPUT);
pin_set_otype(pin, PIN_TYPE_PUSHPULL);
pin_set_ospeed(pin, PIN_SPEED_2MHZ);
pin_set_pupd(pin, PIN_PUPD_NONE);
pin_reset(pin);
}
INT8U keypad_task()
/*****************************************************************************
* Input :
* Output :
* Function : Configures I/O for use with the keypad.
This is necessary, due to sharing PortB with lcd
******************************************************************************/
{
pin_enable();
static BOOLEAN debounce[3][4] = {{0,0,0,0},{0,0,0,0},{0,0,0,0}};
INT8U ascii_chars[3][4] = {{'1', '4', '7', '*'},{'2', '5', '8', '0'},{'3', '6', '9', '#'}};
INT8U x_pins[3] = {KEYPAD_X1, KEYPAD_X2, KEYPAD_X3};
INT8U y_pins[4] = {KEYPAD_Y1, KEYPAD_Y2, KEYPAD_Y3, KEYPAD_Y4};
INT8U return_char = '\0';
// Looping variables
INT8U i;
INT8U j;
//Outer loop, selects column
for (i = 0; i < 3; i++)
{
// Supply voltage to selected column
GPIO_PORTB_DATA_R &= ~(KEYPAD_X_PINS);
GPIO_PORTB_DATA_R |= x_pins[i];
// Loops through buttons in row i
for (j = 0; j < 4; j++)
{
if (GPIO_PORTD_DATA_R & y_pins[j])
{
if (!debounce[i][j])
{
return_char = ascii_chars[i][j];
}
debounce[i][j] = 1;
}
else
{
debounce[i][j] = 0;
}
}
}
GPIO_PORTB_DATA_R &= ~(KEYPAD_X_PINS);
if (return_char != '\0')
{
spi_buffer_push( return_char );
}
pin_disable();
return return_char;
}
void spi_device_init(struct spi_device *device)
{
pin_enable(device->chip_select);
spi_device_deselect(device);
pin_set_mode(device->chip_select, PIN_MODE_OUTPUT);
pin_set_otype(device->chip_select, PIN_TYPE_PUSHPULL);
pin_set_ospeed(device->chip_select, PIN_SPEED_2MHZ);
}
void gpio_enable_pin(unsigned int pin, GPIO_MODE mode)
{
unsigned int param = 0;
#ifdef LPC11Uxx
if (GPIO_PORT(pin) == 0)
{
if ((1 << pin) & GPIO_I2C_MASK)
param = IOCON_PIO_I2CMODE_GPIO;
else if ((1 << pin) & GPIO_AD_MASK)
param = IOCON_PIO_ADMODE;
if ((1 << pin) & GPIO_MODE1_MASK)
param |= (1 << 0);
}
switch (mode)
{
case GPIO_MODE_IN_PULLUP:
param |= IOCON_PIO_MODE_PULL_UP | IOCON_PIO_HYS;
break;
case GPIO_MODE_IN_PULLDOWN:
param |= IOCON_PIO_MODE_PULL_DOWN | IOCON_PIO_HYS;
break;
case GPIO_MODE_IN_FLOAT:
param |= IOCON_PIO_HYS;
break;
default:
break;
}
#else //LPC18xx
if (GPIO_PORT(pin) >= 5)
param = (4 << 0);
switch (mode)
{
case GPIO_MODE_IN_PULLUP:
param |= SCU_SFS_EZI | SCU_SFS_ZIF;
break;
case GPIO_MODE_IN_PULLDOWN:
param |= SCU_SFS_EPUN | SCU_SFS_EPD | SCU_SFS_EZI | SCU_SFS_ZIF;
break;
case GPIO_MODE_IN_FLOAT:
param |= SCU_SFS_EPUN | SCU_SFS_EZI | SCU_SFS_ZIF;
break;
default:
break;
}
#endif //LPC11Uxx
pin_enable(PIN_RAW(pin), param, 0);
if (mode == GPIO_MODE_OUT)
LPC_GPIO->DIR[GPIO_PORT(pin)] |= 1 << GPIO_PIN(pin);
else
LPC_GPIO->DIR[GPIO_PORT(pin)] &= ~(1 << GPIO_PIN(pin));
}
static inline void app_setup_dbg()
{
BAUD baudrate;
pin_enable(DBG_CONSOLE_TX_PIN, STM32_GPIO_MODE_OUTPUT_AF_PUSH_PULL_50MHZ, false);
uart_open(DBG_CONSOLE, UART_MODE_STREAM | UART_TX_STREAM);
baudrate.baud = DBG_CONSOLE_BAUD;
baudrate.data_bits = 8;
baudrate.parity = 'N';
baudrate.stop_bits= 1;
uart_set_baudrate(DBG_CONSOLE, &baudrate);
uart_setup_printk(DBG_CONSOLE);
uart_setup_stdout(DBG_CONSOLE);
open_stdout();
}
void timer_init(void)
{
g_ticks = 0;
rcc_enable(TIMER_RCCDEV);
/* Configure the PPM input pin for input capture. */
pin_enable(PPM_PIN);
pin_set_af(PPM_PIN, TIMER_PPM_PIN_AF);
pin_set_pupd(PPM_PIN, PIN_PUPD_UP);
pin_set_mode(PPM_PIN, PIN_MODE_AF);
#if 0
/* Configure the debugger to freeze TIM1 when the core is halted. */
DBGMCU->APB2FZ |= DBGMCU_APB1_FZ_DBG_TIM1_STOP;
#endif
TIMER_DEV->CR1 = 0;
TIMER_DEV->CR2 = 0;
TIMER_DEV->SMCR = 0;
TIMER_DEV->DIER = TIM_DIER_UIE | DIER_PPM;
TIMER_DEV->CCER = 0;
TIMER_DEV->CCMR1 = CCMR1_PPM;
TIMER_DEV->CCMR2 = CCMR2_PPM;
TIMER_DEV->CCER = CCER_PPM;
TIMER_DEV->CNT = 0;
TIMER_DEV->PSC = TIMER_PRESCALAR;
TIMER_DEV->ARR = 0xFFFF;
#if defined(TIMER_IRQ) /* single IRQ timer */
interrupt_set_priority(TIMER_IRQ, TIMER_IRQ_PRIORITY);
interrupt_enable(TIMER_IRQ);
#else /* multi-IRQ timer */
interrupt_set_priority(TIMER_UP_IRQ, TIMER_IRQ_PRIORITY);
interrupt_set_priority(TIMER_CC_IRQ, TIMER_IRQ_PRIORITY);
interrupt_enable(TIMER_UP_IRQ);
interrupt_enable(TIMER_CC_IRQ);
#endif
TIMER_DEV->CR1 |= TIM_CR1_CEN;
}
