int setup_pins(int gpionum)
{
/*
* Create the required GPIO pin and reserve it
*/
if (gpio_alloc(gpionum))
{
fprintf(stderr, "Error allocating GPIO %d, errno = %d\n", gpionum, errno);
return (1);
}
if (gpio_set_direction(gpionum, "out"))
{
fprintf(stderr, "Error setting GPIO %d direction, errno = %d\n", gpionum, errno);
return (1);
}
if (gpio_write_pin(gpionum, "1"))
{
fprintf(stderr, "Error setting GPIO %d value, errno = %d\n", gpionum, errno);
return (1);
}
return(0);
}
void led_on() {
gpio_write_pin(DISC_LD3, GPIO_HIGH);
gpio_write_pin(DISC_LD4, GPIO_HIGH);
gpio_write_pin(DISC_LD5, GPIO_HIGH);
gpio_write_pin(DISC_LD6, GPIO_HIGH);
gpio_write_pin(DISC_LD7, GPIO_HIGH);
gpio_write_pin(DISC_LD8, GPIO_HIGH);
gpio_write_pin(DISC_LD9, GPIO_HIGH);
gpio_write_pin(DISC_LD10, GPIO_HIGH);
}
void led_off() {
gpio_write_pin(DISC_LD3, GPIO_LOW);
gpio_write_pin(DISC_LD4, GPIO_LOW);
gpio_write_pin(DISC_LD5, GPIO_LOW);
gpio_write_pin(DISC_LD6, GPIO_LOW);
gpio_write_pin(DISC_LD7, GPIO_LOW);
gpio_write_pin(DISC_LD8, GPIO_LOW);
gpio_write_pin(DISC_LD9, GPIO_LOW);
gpio_write_pin(DISC_LD10, GPIO_LOW);
}
void es32f0_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value)
{
const struct pin_index *index;
index = get_pin(pin);
if (index == RT_NULL)
{
return;
}
gpio_write_pin(index->gpio, index->pin, value);
}
/**
****************************************************************************************
* @brief Configure the SPI GPIO and set RS 、 RST GPIO output,Init them.
* @description
*
****************************************************************************************
*/
void oled_io_config(void)
{
// pin mux
syscon_SetPMCR0WithMask(QN_SYSCON,
P03_MASK_PIN_CTRL |
P07_MASK_PIN_CTRL |
P11_MASK_PIN_CTRL |
P13_MASK_PIN_CTRL,
P03_GPIO_3_PIN_CTRL
| P07_GPIO_7_PIN_CTRL
#if (FB_OLED && FB_SPI_OLED)
| P13_SPI1_CLK_PIN_CTRL //P1.3 spi1 clk
| P11_SPI1_DAT_PIN_CTRL //P1.1 spi1 data out
#else
| P13_GPIO_11_PIN_CTRL
| P11_GPIO_9_PIN_CTRL
#endif
);
//Init Gpio with a callback,it's necessary
//gpio_init(gpio_callback);
//set the LCD_RS_PIN an output
gpio_set_direction(OLED_RS_PIN,GPIO_OUTPUT);
gpio_write_pin(OLED_RS_PIN,GPIO_LOW);
//set the LCD_RS_PIN an output
gpio_set_direction(OLED_RST_PIN,GPIO_OUTPUT);
//prevent it reset the lcd
gpio_write_pin(OLED_RST_PIN,GPIO_HIGH);
#if (FB_OLED && FB_IIC_OLED)
//set the LCD_RS_PIN an output
gpio_set_direction(OLED_SCLK_PIN,GPIO_OUTPUT);
//prevent it reset the lcd
gpio_write_pin(OLED_SCLK_PIN,GPIO_HIGH);
//set the LCD_RS_PIN an output
gpio_set_direction(OLED_SDIN_PIN,GPIO_OUTPUT);
//prevent it reset the lcd
gpio_write_pin(OLED_SDIN_PIN,GPIO_HIGH);
#endif
}
/**
****************************************************************************************
* @brief Set led on/off
* @param[in] idx 1~5 -> led 1~5
* @param[in] enable on/off
* @description
* This function switchs on/off led individually.
****************************************************************************************
*/
void led_set(uint32_t idx, enum led_st enable)
{
enum gpio_pin reg;
switch(idx)
{
case 1:
reg = LED1_PIN;
break;
case 2:
reg = LED2_PIN;
break;
default:
return;
}
gpio_write_pin(reg, (enum gpio_level)enable);
}
/**
****************************************************************************************
* @brief Setup the microcontroller system.
*
* Initialize the system clock and pins.
*****************************************************************************************
*/
void SystemInit(void)
{
/*
**************************
* Sub module clock setting
**************************
*/
// Disable all peripheral clock, will be enabled in the driver initilization.
timer_clock_off(QN_TIMER0);
timer_clock_off(QN_TIMER1);
timer_clock_off(QN_TIMER2);
timer_clock_off(QN_TIMER3);
uart_clock_off(QN_UART0);
uart_clock_off(QN_UART1);
spi_clock_off(QN_SPI0);
usart_reset((uint32_t) QN_SPI1);
spi_clock_off(QN_SPI1);
flash_clock_off();
gpio_clock_off();
adc_clock_off();
dma_clock_off();
pwm_clock_off();
// Configure sytem clock.
syscon_set_sysclk_src(CLK_XTAL, __XTAL);
syscon_set_ahb_clk(__AHB_CLK);
syscon_set_ble_clk(__BLE_CLK);
syscon_set_apb_clk(__APB_CLK);
syscon_set_timer_clk(__TIMER_CLK);
syscon_set_usart_clk((uint32_t)QN_UART0, __USART_CLK);
syscon_set_usart_clk((uint32_t)QN_UART1, __USART_CLK);
clk32k_enable(__32K_TYPE);
/*
**************************
* IO configuration
**************************
*/
SystemIOCfg();
/*
**************************
* Peripheral setting
**************************
*/
// GPIO initialization for led, button & test control pin.
gpio_init(gpio_interrupt_callback);
// LED
led_init();
#if (FB_OLED && FB_SPI_OLED)
spi_init(QN_SPI1, SPI_BITRATE(10000), SPI_8BIT, SPI_MASTER_MOD);
#endif
/// Firefly add
#if (FB_OLED)
OLED_Init(); //初始化 OLED
OLED_Clear(); //清屏 OLED
OLED_ShowString(0,0," Firefly Team ");
OLED_ShowString(0,2," Wait ... ");
// OLED_ShowString(4,4,"Please wait...");
#endif
//#if (FB_OLED)
// OLED_Init(); //初始化OLED
// delay(10000);
// OLED_Clear(); //清屏 OLED
// delay(10000);
// OLED_ShowCHinese(9,0,0);
// OLED_ShowCHinese(27,0,1);
// OLED_ShowCHinese(45,0,2);
// OLED_ShowCHinese(63,0,3);
// OLED_ShowCHinese(81,0,4);
// OLED_ShowCHinese(99,0,5);
//#endif
#if (defined(CFG_PRO_TEST))
gpio_pull_set(BUTTON1_PIN,GPIO_PULL_UP);
gpio_set_direction(BUTTON1_PIN,GPIO_INPUT);
if (gpio_read_pin(BUTTON1_PIN) == GPIO_LOW)
app_env.pro_test_flag = TRUE;
else
app_env.pro_test_flag = FALSE;
#endif
// Test controll pin is input to check work mode
#if (defined(QN_TEST_CTRL_PIN))
gpio_pull_set(QN_TEST_CTRL_PIN, GPIO_PULL_UP);
gpio_set_direction_field(QN_TEST_CTRL_PIN, (uint32_t)GPIO_INPUT);
#if (defined(CFG_HCI_UART))
// Initialize HCI UART port
uart_init(QN_HCI_PORT, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_HCI_PORT, MASK_ENABLE);
uart_rx_enable(QN_HCI_PORT, MASK_ENABLE);
#elif (defined(CFG_HCI_SPI))
// Initialize HCI SPI port
spi_init(QN_HCI_PORT, SPI_BITRATE(1000000), SPI_8BIT, SPI_SLAVE_MOD);
gpio_set_direction_field(CFG_HCI_SPI_WR_CTRL_PIN, (uint32_t)GPIO_OUTPUT);
gpio_write_pin(CFG_HCI_SPI_WR_CTRL_PIN, GPIO_HIGH);
#endif
#endif
// Button
button_init();
#if (QN_DBG_PRINT)
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
}
/**
****************************************************************************************
* @brief Disable hardware flow control
* @param[in] UART QN_UART0 or QN_UART1
* @return TRUE
* @description
* Disable specified UART port hardware flow control
*****************************************************************************************
*/
bool uart_flow_off(QN_UART_TypeDef *UART)
{
//uart_uart_SetCRWithMask(UART, UART_MASK_CTS_EN|UART_MASK_RTS_EN, MASK_DISABLE);
//return true;
bool rt = false;
uint32_t int_restore = 0;
// Disable UART interrupt
#if CONFIG_ENABLE_DRIVER_UART0==TRUE
if(UART == QN_UART0)
int_restore = NVIC->ISER[0] & ((1<<UART0_TX_IRQn) | (1<<UART0_RX_IRQn));
#endif
#if CONFIG_ENABLE_DRIVER_UART1==TRUE
if(UART == QN_UART1)
int_restore = NVIC->ISER[0] & ((1<<UART1_TX_IRQn) | (1<<UART1_RX_IRQn));
#endif
NVIC->ICER[0] = int_restore;
do
{
// Check if no tx is ongoing
if(UART_TX_FREE == uart_check_tx_free(UART))
break;
// Disable rx (RTS/CTS -> GPIO high)
#if CONFIG_ENABLE_DRIVER_UART0==TRUE
if(UART == QN_UART0)
{
syscon_SetPMCR0WithMask(QN_SYSCON,
P02_MASK_PIN_CTRL | P01_MASK_PIN_CTRL,
P02_GPIO_2_PIN_CTRL | P01_GPIO_1_PIN_CTRL);
gpio_write_pin(GPIO_P02, GPIO_HIGH);
gpio_write_pin(GPIO_P01, GPIO_HIGH);
}
#endif
#if CONFIG_ENABLE_DRIVER_UART1==TRUE
if(UART == QN_UART1)
{
// NOTE!!!!!
// Assume UART1 used P2.2 and P3.6 as RTS/CTS. Other case this snippet should be modified.
syscon_SetPMCR1WithMask(QN_SYSCON,
P22_MASK_PIN_CTRL | P36_MASK_PIN_CTRL,
P22_GPIO_18_PIN_CTRL | P36_GPIO_30_PIN_CTRL);
gpio_write_pin(GPIO_P22, GPIO_HIGH);
gpio_write_pin(GPIO_P36, GPIO_HIGH);
}
#endif
// Wait for 1 bytes duration to guarantee host has not started a tx at this time.
// Assume buadrate 115200
delay(100);
// Check if data has been received during the waiting time
if(uart_uart_GetIntFlag(UART) & UART_MASK_RX_IF)
{
// Switch RTS/CTS back
#if CONFIG_ENABLE_DRIVER_UART0==TRUE
if(UART == QN_UART0)
{
syscon_SetPMCR0WithMask(QN_SYSCON,
P02_MASK_PIN_CTRL | P01_MASK_PIN_CTRL,
P02_UART0_RTS_PIN_CTRL | P01_UART0_CTS_PIN_CTRL);
}
#endif
#if CONFIG_ENABLE_DRIVER_UART1==TRUE
if(UART == QN_UART1)
{
// NOTE!!!!!
// Assume UART1 used P2.2 and P3.6 as RTS/CTS. Other case this snippet should be modified.
syscon_SetPMCR1WithMask(QN_SYSCON,
P22_MASK_PIN_CTRL | P36_MASK_PIN_CTRL,
P22_UART1_RTS_PIN_CTRL | P36_UART1_CTS_PIN_CTRL);
}
#endif
// failed.
break;
}
// success.
rt = true;
}
while(false);
// Restore uart interrupt status
NVIC->ISER[0] = int_restore;
return rt;
}
/**
****************************************************************************************
* @brief Setup the microcontroller system.
*
* Initialize the system clock and pins.
*****************************************************************************************
*/
void SystemInit(void)
{
/*
**************************
* Sub module clock setting
**************************
*/
// Reset SPI1 module(since the default register value was changed in bootloader)
syscon_SetCRSS(QN_SYSCON, SYSCON_MASK_USART1_RST);
syscon_SetCRSC(QN_SYSCON, SYSCON_MASK_USART1_RST);
/*
Disable all peripheral clock, will be enabled in the driver initilization.
The next function performs the equivalent effect of a collection of these functions.
timer_clock_off(QN_TIMER0);
timer_clock_off(QN_TIMER1);
timer_clock_off(QN_TIMER2);
timer_clock_off(QN_TIMER3);
uart_clock_off(QN_UART0);
uart_clock_off(QN_UART1);
spi_clock_off(QN_SPI0);
spi_clock_off(QN_SPI1);
flash_clock_off();
gpio_clock_off();
adc_clock_off();
dma_clock_off();
pwm_clock_off();
*/
syscon_SetCRSS(QN_SYSCON, SYSCON_MASK_GATING_TIMER0
| SYSCON_MASK_GATING_TIMER1
| SYSCON_MASK_GATING_TIMER2
| SYSCON_MASK_GATING_TIMER3
| SYSCON_MASK_GATING_UART0
| SYSCON_MASK_GATING_UART1
| SYSCON_MASK_GATING_SPI0
| SYSCON_MASK_GATING_SPI1
| SYSCON_MASK_GATING_SPI_AHB
| SYSCON_MASK_GATING_GPIO
| SYSCON_MASK_GATING_ADC
| SYSCON_MASK_GATING_DMA
| SYSCON_MASK_GATING_PWM);
// Configure sytem clock.
syscon_set_sysclk_src(CLK_XTAL, __XTAL);
syscon_set_ahb_clk(__AHB_CLK);
syscon_set_ble_clk(__BLE_CLK);
syscon_set_apb_clk(__APB_CLK);
syscon_set_timer_clk(__TIMER_CLK);
syscon_set_usart_clk((uint32_t)QN_UART0, __USART_CLK);
syscon_set_usart_clk((uint32_t)QN_UART1, __USART_CLK);
clk32k_enable(__32K_TYPE);
/*
**************************
* IO configuration
**************************
*/
SystemIOCfg();
/*
**************************
* Peripheral setting
**************************
*/
// GPIO initialization for led, button & test control pin.
gpio_init(gpio_interrupt_callback);
// LED
led_init();
// Test controll pin is input to check work mode
#if (defined(QN_TEST_CTRL_PIN))
gpio_pull_set(QN_TEST_CTRL_PIN, GPIO_PULL_UP);
gpio_set_direction_field(QN_TEST_CTRL_PIN, (uint32_t)GPIO_INPUT);
#if (defined(CFG_HCI_UART))
// Initialize HCI UART port
uart_init(QN_HCI_PORT, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_HCI_PORT, MASK_ENABLE);
uart_rx_enable(QN_HCI_PORT, MASK_ENABLE);
#elif (defined(CFG_HCI_SPI))
// Initialize HCI SPI port
spi_init(QN_HCI_PORT, SPI_BITRATE(1000000), SPI_8BIT, SPI_SLAVE_MOD);
gpio_set_direction_field(CFG_HCI_SPI_WR_CTRL_PIN, (uint32_t)GPIO_OUTPUT);
gpio_write_pin(CFG_HCI_SPI_WR_CTRL_PIN, GPIO_HIGH);
#endif
#endif
// Button
button_init();
#if (QN_DBG_PRINT)
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
}
/**
****************************************************************************************
* @brief Setup the microcontroller system.
*
* Initialize the system clock and pins.
*****************************************************************************************
*/
void SystemInit(void)
{
/*
**************************
* Sub module clock setting
**************************
*/
// Disable all peripheral clock, will be enabled in the driver initilization.
timer_clock_off(QN_TIMER0);
timer_clock_off(QN_TIMER1);
timer_clock_off(QN_TIMER2);
timer_clock_off(QN_TIMER3);
uart_clock_off(QN_UART0);
uart_clock_off(QN_UART1);
spi_clock_off(QN_SPI0);
usart_reset((uint32_t) QN_SPI1);
spi_clock_off(QN_SPI1);
flash_clock_off();
gpio_clock_off();
adc_clock_off();
dma_clock_off();
pwm_clock_off();
// Configure sytem clock.
syscon_set_sysclk_src(CLK_XTAL, __XTAL);
syscon_set_ahb_clk(__AHB_CLK);
syscon_set_ble_clk(__BLE_CLK);
syscon_set_apb_clk(__APB_CLK);
syscon_set_timer_clk(__TIMER_CLK);
syscon_set_usart_clk((uint32_t)QN_UART0, __USART_CLK);
syscon_set_usart_clk((uint32_t)QN_UART1, __USART_CLK);
clk32k_enable(__32K_TYPE);
// if pull down GPIO_P12 when power on,it will enter the test mode
#if defined(CFG_ALL_GPIO_TEST)
//set GPIO_P12 direction to GPIO_INPUT
syscon_SetPMCR0(QN_SYSCON,P12_GPIO_10_PIN_CTRL);
gpio_init(gpio_interrupt_callback);
gpio_pull_set(GPIO_P12, GPIO_PULL_UP);
gpio_set_direction_field(GPIO_P12, (uint32_t)GPIO_INPUT);
//check if it's pull down
if (gpio_read_pin(GPIO_P12) == GPIO_LOW)
{
//set a flag to enter test mode until device reset
app_env.test_flag = TRUE;
}
else
app_env.test_flag = FALSE;
#endif
/*
**************************
* IO configuration
**************************
*/
SystemIOCfg();
/*
**************************
* Peripheral setting
**************************
*/
// GPIO initialization for led, button & test control pin.
gpio_init(gpio_interrupt_callback);
// LED
led_init();
// Test controll pin is input to check work mode
#if (defined(QN_TEST_CTRL_PIN))
gpio_pull_set(QN_TEST_CTRL_PIN, GPIO_PULL_UP);
gpio_set_direction_field(QN_TEST_CTRL_PIN, (uint32_t)GPIO_INPUT);
#if (defined(CFG_HCI_UART))
// Initialize HCI UART port
uart_init(QN_HCI_PORT, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_HCI_PORT, MASK_ENABLE);
uart_rx_enable(QN_HCI_PORT, MASK_ENABLE);
#elif (defined(CFG_HCI_SPI))
// Initialize HCI SPI port
spi_init(QN_HCI_PORT, SPI_BITRATE(1000000), SPI_8BIT, SPI_SLAVE_MOD);
gpio_set_direction_field(CFG_HCI_SPI_WR_CTRL_PIN, (uint32_t)GPIO_OUTPUT);
gpio_write_pin(CFG_HCI_SPI_WR_CTRL_PIN, GPIO_HIGH);
#endif
#endif
#if defined(QN_COM_UART)
// Initialize User UART port
uart_init(QN_COM_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_COM_UART, MASK_ENABLE);
uart_rx_enable(QN_COM_UART, MASK_ENABLE);
#endif
#if (QN_DBG_PRINT)
// Initialize Debug UART port
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
// if enter test mode flag had been seted,enter a loop to test all GPIO.
#if (defined(CFG_ALL_GPIO_TEST))
if (app_env.test_flag == TRUE)
{
//get a warnning to user
QPRINTF("\r\n@@@You pull down the GPIO_level of GPIO_P12 when power on,so it will enter the test mode!");
while(1)
{
all_gpio_test();
}
}
#endif
}
/**
****************************************************************************************
* @brief Setup the microcontroller system.
*
* Initialize the system clock and pins.
*****************************************************************************************
*/
void SystemInit(void)
{
/*
**************************
* Sub module clock setting
**************************
*/
// Disable all peripheral clock, will be enabled in the driver initilization.
timer_clock_off(QN_TIMER0);
timer_clock_off(QN_TIMER1);
timer_clock_off(QN_TIMER2);
timer_clock_off(QN_TIMER3);
uart_clock_off(QN_UART0);
uart_clock_off(QN_UART1);
spi_clock_off(QN_SPI0);
usart_reset((uint32_t) QN_SPI1);
spi_clock_off(QN_SPI1);
flash_clock_off();
gpio_clock_off();
adc_clock_off();
dma_clock_off();
pwm_clock_off();
// Configure sytem clock.
syscon_set_sysclk_src(CLK_XTAL, __XTAL);
syscon_set_ahb_clk(__AHB_CLK);
syscon_set_ble_clk(__BLE_CLK);
syscon_set_apb_clk(__APB_CLK);
syscon_set_timer_clk(__TIMER_CLK);
syscon_set_usart_clk((uint32_t)QN_UART0, __USART_CLK);
syscon_set_usart_clk((uint32_t)QN_UART1, __USART_CLK);
clk32k_enable(__32K_TYPE);
/*
**************************
* IO configuration
**************************
*/
SystemIOCfg();
/*
**************************
* Peripheral setting
**************************
*/
// GPIO initialization for led, button & test control pin.
gpio_init(gpio_interrupt_callback);
// LED
led_init();
// Test controll pin is input to check work mode
#if (defined(QN_TEST_CTRL_PIN))
gpio_pull_set(QN_TEST_CTRL_PIN, GPIO_PULL_UP);
gpio_set_direction_field(QN_TEST_CTRL_PIN, (uint32_t)GPIO_INPUT);
#if (defined(CFG_HCI_UART))
// Initialize HCI UART port
uart_init(QN_HCI_PORT, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_HCI_PORT, MASK_ENABLE);
uart_rx_enable(QN_HCI_PORT, MASK_ENABLE);
#elif (defined(CFG_HCI_SPI))
// Initialize HCI SPI port
spi_init(QN_HCI_PORT, SPI_BITRATE(1000000), SPI_8BIT, SPI_SLAVE_MOD);
gpio_set_direction_field(CFG_HCI_SPI_WR_CTRL_PIN, (uint32_t)GPIO_OUTPUT);
gpio_write_pin(CFG_HCI_SPI_WR_CTRL_PIN, GPIO_HIGH);
#endif
#endif
// Button
button_init();
#if (QN_DBG_PRINT)
uart_init(QN_DEBUG_UART, USARTx_CLK(0), UART_9600);
uart_tx_enable(QN_DEBUG_UART, MASK_ENABLE);
uart_rx_enable(QN_DEBUG_UART, MASK_ENABLE);
#endif
}
int main(int argc, char *argv[])
{
int i;
/*
* Create the required GPIO pins and reserve them
*/
/*
* Setup GPIO30. Output and LOW
*/
if (gpio_set_direction(30, "out"))
err_exit();
if (gpio_write_pin(30, "0"))
err_exit();
/*
* Set up GPIO 46. Output and LOW
*/
if (gpio_set_direction(46, "out"))
err_exit();
if (gpio_write_pin(46, "0"))
err_exit();
/*
* Setup GPIO7. Output
*/
if (gpio_set_direction(7, "out"))
err_exit();
/*
* Flash the LED 10 times with ~1 second delay in between
*/
for (i=0; i < 10; i++)
{
if (gpio_write_pin(7, "0")) /* Turn the LED off */
err_exit();
sleep(1); /* Wait ~1 second */
if (gpio_write_pin(7, "1")) /* Turn the LED on */
err_exit();
sleep(1);
}
/*
* Clean up
*/
if (gpio_write_pin(7, "0")) /* Turn the LED off */
err_exit();
if (gpio_dealloc(30)) /* Unreserve /sys/class/gpio/gpio30 (Internal MUX) */
err_exit();
if (gpio_dealloc(46)) /* Unreserve /sys/class/gpio/gpio46 (Internal MUX) */
err_exit();
if (gpio_dealloc(7)) /* Unreserve /sys/class/gpio/gpio7 (Arduino IO13) */
err_exit();
return(0);
}
