void imu_aspirin_arch_init(void) {
// This was needed for Lisa/L????
#if 0
/* Set "mag ss" and "mag reset" as floating inputs ------------------------*/
/* "mag ss" (PC12) is shorted to I2C2 SDA */
/* "mag reset" (PC13) is shorted to I2C2 SCL */
rcc_periph_clock_enable(RCC_GPIOC);
gpio_set_mode(GPIOC, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO12 | GPIO13);
#endif
/* Gyro --------------------------------------------------------------------*/
/* configure external interrupt exti15_10 on PC14( gyro int ) */
rcc_periph_clock_enable(RCC_GPIOC);
rcc_periph_clock_enable(RCC_AFIO);
gpio_set_mode(GPIOC, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO14);
#ifdef ASPIRIN_USE_GYRO_INT
exti_select_source(EXTI14, GPIOC);
exti_set_trigger(EXTI14, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI14);
#endif
/* configure external interrupt exti2 on PB2( accel int ) */
rcc_periph_clock_enable(RCC_GPIOB);
gpio_set_mode(GPIOB, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO2);
exti_select_source(EXTI2, GPIOB);
exti_set_trigger(EXTI2, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI2);
}
void exti0_isr()
{
exti_reset_request(EXTI0);
if (exti_direction == FALLING) {
gpio_set(GPIOC, GPIO12);
exti_direction = RISING;
exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING);
} else {
gpio_clear(GPIOC, GPIO12);
exti_direction = FALLING;
exti_set_trigger(EXTI0, EXTI_TRIGGER_FALLING);
}
}
void BUTTON_DISCO_USER_isr(void)
{
exti_reset_request(BUTTON_DISCO_USER_EXTI);
state.pressed = true;
if (state.falling) {
state.falling = false;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_RISING);
state.hold_time = TIM_CNT(TIMER_BUTTON_PRESS);
} else {
state.falling = true;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_FALLING);
state.hold_time = TIM_CNT(TIMER_BUTTON_PRESS) = 0;
}
}
// setup screen and pad
void interface_setup() {
// SPI
gpio_mode_setup(INTERFACE_SPI_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, INTERFACE_SPI_CLK_PIN | INTERFACE_SPI_MISO_PIN | INTERFACE_SPI_MOSI_PIN );
gpio_set_af(INTERFACE_SPI_PORT, GPIO_AF5, INTERFACE_SPI_CLK_PIN | INTERFACE_SPI_MISO_PIN | INTERFACE_SPI_MOSI_PIN);
gpio_mode_setup(GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO0 | GPIO1);
gpio_mode_setup(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO4 | GPIO5);
rcc_periph_clock_enable(RCC_SPI1);
spi_init_master(SPI1, SPI_CR1_BAUDRATE_FPCLK_DIV_4,
SPI_CR1_CPOL_CLK_TO_0_WHEN_IDLE,
SPI_CR1_CPHA_CLK_TRANSITION_1,
SPI_CR1_DFF_8BIT,
SPI_CR1_MSBFIRST);
spi_enable_ss_output(SPI1);
spi_enable(SPI1);
// OLED
ssd1306_setup();
// PAD
pad_setup();
nvic_set_priority(NVIC_EXTI0_IRQ,0x00);
/* Enable EXTI0 interrupt. */
nvic_enable_irq(NVIC_EXTI0_IRQ);
gpio_mode_setup(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO0);
/* Configure the EXTI subsystem. */
exti_select_source(EXTI0, GPIOA);
exti_set_trigger(EXTI0, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI0);
}
//Setup hardware
TouchADS7843::TouchADS7843(void)
{
//Enable clocks
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_SPI1EN); //SPI
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN); //SPI
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN); //PEN_INT
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN); //AFIO (EXTI)
//Setup GPIO
gpio_set_mode(GPIOC, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BIT13); //PEN_INT
gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BIT6); //MISO
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, BIT4); //CS
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, BIT5 | BIT7); //MOSI, SCK
//Set up SPI as mater
_cs(1);
spi_enable_software_slave_management(SPI1);
spi_set_nss_high(SPI1);
spi_set_baudrate_prescaler(SPI1, 7);
spi_set_clock_polarity_0(SPI1);
spi_set_clock_phase_0(SPI1);
spi_set_dff_8bit(SPI1);
spi_set_master_mode(SPI1);
spi_enable(SPI1);
//Enable PEN_INT
nvic_enable_irq(NVIC_EXTI15_10_IRQ);
exti_select_source(EXTI13, GPIOC);
exti_set_trigger(EXTI13, EXTI_TRIGGER_BOTH);
exti_reset_request(EXTI13);
exti_enable_request(EXTI13);
}
static void irq_setup(void)
{
exti_select_source(EXTI9, GPIOB);
exti_set_trigger(EXTI9, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI9);
nvic_enable_irq(NVIC_EXTI9_5_IRQ);
}
void exti_init()
{
#ifdef MSP430
/*
* Configure P2.0 as input, with IRQ triggered on falling edge
*/
P1IES |= BIT0; // Hi/Lo edge interrupt
P1IFG &= ~BIT0; // Clear flag before enabling interrupt
P1IE |= BIT0; // Enable interrupt
__bis_SR_register(GIE);
#else
/*
* Configure D2 as input, with IRQ triggered on falling edge
*/
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPDEN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN);
nvic_enable_irq(NVIC_EXTI2_IRQ);
gpio_set_mode(GPIOD, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO2);
exti_select_source(EXTI2, GPIOD);
exti_set_trigger(EXTI2, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI2);
#endif
}
/**
* GPIO initialisaion: clocking + pins setup
*/
void GPIO_init(){
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN |
RCC_APB2ENR_IOPBEN | RCC_APB2ENR_IOPCEN | RCC_APB2ENR_IOPDEN |
RCC_APB2ENR_IOPEEN);
/*
* Setup EXTI on PA4 (PPS input from GPS) - pull down
* EXTI on PA5 - also pull down (trigger for time measurement)
*/
gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO4 | GPIO5);
//AFIO_EXTICR2 = 0;
exti_enable_request(EXTI4 | EXTI5);
// trigger on rising edge
exti_set_trigger(EXTI4 | EXTI5, EXTI_TRIGGER_RISING);
nvic_enable_irq(NVIC_EXTI4_IRQ);
nvic_enable_irq(NVIC_EXTI9_5_IRQ);
/*
// Buttons: pull-up input
gpio_set_mode(BTNS_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN,
BTN_S2_PIN | BTN_S3_PIN);
// turn on pull-up
gpio_set(BTNS_PORT, BTN_S2_PIN | BTN_S3_PIN);
// LEDS: opendrain output
gpio_set_mode(LEDS_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN,
LED_D1_PIN | LED_D2_PIN);
// turn off LEDs
gpio_set(LEDS_PORT, LED_D1_PIN | LED_D2_PIN);*/
/*
// USB_DISC: push-pull
gpio_set_mode(USB_DISC_PORT, GPIO_MODE_OUTPUT_2_MHZ,
GPIO_CNF_OUTPUT_PUSHPULL, USB_DISC_PIN);
// USB_POWER: open drain, externall pull down with R7 (22k)
gpio_set_mode(USB_POWER_PORT, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, USB_POWER_PIN);
*/
}
void BUTTON_DISCO_USER_isr(void)
{
exti_reset_request(BUTTON_DISCO_USER_EXTI);
if (state.falling) {
gpio_clear(LED_DISCO_BLUE_PORT, LED_DISCO_BLUE_PIN);
state.falling = false;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_RISING);
unsigned int x = TIM_CNT(TIM7);
printf("held: %u ms\n", x);
} else {
gpio_set(LED_DISCO_BLUE_PORT, LED_DISCO_BLUE_PIN);
printf("Pushed down!\n");
TIM_CNT(TIM7) = 0;
state.falling = true;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_FALLING);
}
}
void platform_mrf_interrupt_enable(void) {
// Enable EXTI0 interrupt.
nvic_enable_irq(MRF_INTERRUPT_NVIC);
/* Configure the EXTI subsystem. */
exti_select_source(MRF_INTERRUPT_EXTI, MRF_INTERRUPT_PORT);
exti_set_trigger(MRF_INTERRUPT_EXTI, EXTI_TRIGGER_FALLING);
exti_enable_request(MRF_INTERRUPT_EXTI);
}
void imu_krooz_sd_arch_init(void)
{
rcc_periph_clock_enable(RCC_SYSCFG);
rcc_periph_clock_enable(RCC_GPIOB);
rcc_periph_clock_enable(RCC_GPIOB);
gpio_mode_setup(GPIOB, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO5);
gpio_mode_setup(GPIOC, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO6);
nvic_enable_irq(NVIC_EXTI9_5_IRQ);
exti_select_source(EXTI5, GPIOB);
exti_select_source(EXTI6, GPIOC);
exti_set_trigger(EXTI5, EXTI_TRIGGER_RISING);
exti_set_trigger(EXTI6, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI5);
exti_enable_request(EXTI6);
nvic_set_priority(NVIC_EXTI9_5_IRQ, 0x0F);
}
void ROBOT_initIsr(uint32_t port, uint32_t exti, uint8_t irqn, uint8_t priority, enum exti_trigger_type trig)
{
// exti
exti_select_source(exti, port);
exti_set_trigger(exti, trig);
exti_enable_request(exti);
// enable interrupt
nvic_enable_irq(irqn);
nvic_set_priority(irqn,priority);
}
/* *************** HAL API functions **************************************** */
void hal_init( void ) {
int ret = 0;
/* Reset variables used in file. */
hal_system_time = 0;
// hal_reset_flags();
/* Enable GPIOA clock. Enable AFIO clock. */
rcc_peripheral_enable_clock(&RCC_APB2ENR,
RCC_APB2ENR_IOPAEN |
RCC_APB2ENR_IOPBEN |
RCC_APB2ENR_IOPCEN |
RCC_APB2ENR_SPI1EN |
RCC_APB2ENR_AFIOEN );
/* The following pins are output pins. */
gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,RST); //reset
gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,SLP_TR); //sleep
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,SEL); //cs
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL,
SCK | MOSI | MISO); //sck mosi miso
spi_disable(RF_SPI);
SPI2_I2SCFGR = 0;
/* Setup SPI parameters. */
spi_init_master(RF_SPI, SPI_CR1_BAUDRATE_FPCLK_DIV_16, SPI_CR1_CPOL_CLK_TO_0_WHEN_IDLE,
SPI_CR1_CPHA_CLK_TRANSITION_1, SPI_CR1_DFF_8BIT, SPI_CR1_MSBFIRST);
spi_set_unidirectional_mode(RF_SPI);
spi_set_full_duplex_mode(RF_SPI); /* Not receive-only */
spi_enable_software_slave_management(RF_SPI);
spi_set_nss_high(RF_SPI);
spi_enable_ss_output(RF_SPI); /* Required, see NSS, 25.3.1 section. */
/* Finally enable the SPI. */
spi_enable(RF_SPI);
/* Set GPIO4 (in GPIO port C) to 'input float'. */
gpio_set_mode(RF_IRQ_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, RF_IRQ_PIN);
gpio_clear(RF_IRQ_PORT, RF_IRQ_PIN);
/* Configure the EXTI subsystem. */
exti_select_source(EXTI4, RF_IRQ_PORT);
exti_set_trigger(EXTI4, EXTI_TRIGGER_RISING);
exti_enable_request(EXTI4);
exti_reset_request(EXTI4);
PRINTF("Enabling interrupts\r\n");
/* Enable EXTI0 interrupt. */
nvic_enable_irq(NVIC_EXTI4_IRQ);
nvic_set_priority(NVIC_EXTI4_IRQ,4);
//@@@!? timer_init();
// ret = trx_init();
// if(ret!=0)
// {
// PRINTF("rf231:hal init failed\r\n");
// }else
// {
// PRINTF("rf231:hal init success\r\n");
// }
}
int buttons_init(void)
{
gpio_mode_setup(GPIOH, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, GPIO0 | GPIO1);
exti_select_source(EXTI1, GPIOH); // Button 1
exti_select_source(EXTI0, GPIOH); // Button 2
exti_set_trigger(EXTI0 | EXTI1, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI0 | EXTI1);
nvic_enable_irq(NVIC_EXTI0_IRQ);
nvic_enable_irq(NVIC_EXTI1_IRQ);
return 0;
}
void hal_uart_dma_set_csr_irq_handler( void (*the_irq_handler)(void)){
if (the_irq_handler){
/* Configure the EXTI13 interrupt (USART3_CTS is on PB13) */
nvic_enable_irq(NVIC_EXTI15_10_IRQ);
exti_select_source(EXTI13, GPIOB);
exti_set_trigger(EXTI13, EXTI_TRIGGER_RISING);
exti_enable_request(EXTI13);
} else {
exti_disable_request(EXTI13);
nvic_disable_irq(NVIC_EXTI15_10_IRQ);
}
cts_irq_handler = the_irq_handler;
}
void jack_setup() {
nvic_set_priority(NVIC_EXTI1_IRQ,0x00);
/* Enable EXTI1 interrupt. */
nvic_enable_irq(NVIC_EXTI1_IRQ);
gpio_mode_setup(JACK_SENSE_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, JACK_SENSE_PIN);
/* Configure the EXTI subsystem. */
exti_select_source(EXTI1, JACK_SENSE_PORT);
exti_set_trigger(EXTI1, EXTI_TRIGGER_BOTH);
exti_enable_request(EXTI1);
}
static void setup_buttons(void)
{
/* Enable EXTI0 interrupt. */
nvic_enable_irq(BUTTON_DISCO_USER_NVIC);
gpio_mode_setup(BUTTON_DISCO_USER_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE,
BUTTON_DISCO_USER_PIN);
/* Configure the EXTI subsystem. */
exti_select_source(BUTTON_DISCO_USER_EXTI, BUTTON_DISCO_USER_PORT);
state.falling = false;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_RISING);
exti_enable_request(BUTTON_DISCO_USER_EXTI);
}
/** @brief Enable the wakeup timer interrupt
@warning You must unlock the registers before using this function
*/
void rtc_enable_wakeup_timer_interrupt(void) {
// FTFM:
// To enable the RTC Wakeup interrupt, the following sequence is required:
// 1. Configure and enable the EXTI Line 22 in interrupt mode and select the
// rising edge sensitivity.
exti_enable_request(EXTI22);
exti_set_trigger(EXTI22, EXTI_TRIGGER_RISING);
// 2. Configure and enable the RTC_WKUP IRQ channel in the NVIC.
nvic_enable_irq(NVIC_RTC_WKUP_IRQ);
nvic_set_priority(NVIC_RTC_WKUP_IRQ, 1);
// 3. Configure the RTC to generate the RTC wakeup timer event.
RTC_CR |= RTC_CR_WUTIE; // Enable the interrupt
}
void hmc5843_arch_init( void ) {
/* configure external interrupt exti5 on PB5( mag int ) */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPBEN | RCC_APB2ENR_AFIOEN);
gpio_set_mode(GPIOB, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO5);
#ifdef HMC5843_USE_INT
exti_select_source(EXTI5, GPIOB);
exti_set_trigger(EXTI5, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI5);
nvic_set_priority(NVIC_EXTI9_5_IRQ, 0x0f);
nvic_enable_irq(NVIC_EXTI9_5_IRQ);
#endif
}
void ll_init() {
rcc_clock_setup_in_hsi_out_48mhz();
// Initialize used GPIOs and enable peripheral clocks
rcc_periph_clock_enable(RCC_GPIOA);
rcc_periph_clock_enable(RCC_GPIOC);
rcc_periph_clock_enable(RCC_GPIOF);
rcc_periph_reset_pulse(RST_GPIOA);
rcc_periph_reset_pulse(RST_GPIOC);
rcc_periph_reset_pulse(RST_GPIOF);
// Pin configuration
gpio_mode_setup(GPIOA, GPIO_MODE_INPUT,
GPIO_PUPD_NONE, USER_BUTTON);
gpio_mode_setup(GPIOC, GPIO_MODE_OUTPUT,
GPIO_PUPD_NONE, LED0 | LED1);
gpio_mode_setup(GPIOC, GPIO_MODE_INPUT,
GPIO_PUPD_NONE, CC3000_IRQ);
gpio_mode_setup(GPIOC, GPIO_MODE_OUTPUT,
GPIO_PUPD_NONE, CC3000_DOUT|CC3000_CLK|CC3000_EN);
gpio_mode_setup(GPIOF, GPIO_MODE_INPUT,
GPIO_PUPD_NONE, CC3000_DIN);
gpio_set(GPIOF, CC3000_CS);
gpio_mode_setup(GPIOF, GPIO_MODE_OUTPUT,
GPIO_PUPD_NONE, CC3000_CS);
// Enable EXTI0 IRQ on user pin
exti_select_source(EXTI0, GPIOA);
exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING);
exti_enable_request(EXTI0);
// clear counter so it starts right away
STK_CVR=0;
// Set processor clock for systick
// this does it, the systick_set_clocksource doesn't seem to do the
// right thing.
STK_CSR|=4;
// 8MHZ clock -> systick every 1ms
systick_set_reload(8000);
systick_counter_enable();
}
void max1168_arch_init( void ) {
/* configure external interrupt exti2 on PD2( data ready ) v1.0*/
/* PB2( data ready ) v1.1*/
rcc_periph_clock_enable(RCC_GPIOB);
rcc_periph_clock_enable(RCC_AFIO);
gpio_set_mode(GPIOB, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO2);
exti_select_source(EXTI2, GPIOB);
exti_set_trigger(EXTI2, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI2);
nvic_set_priority(NVIC_EXTI2_IRQ, 0xF);
nvic_enable_irq(NVIC_EXTI2_IRQ);
}
void PPMin_Init()
{
UART_Stop(); // disable USART1 for GPIO PA9 & PA10 (Trainer Tx(PA9) & Rx(PA10))
/* Enable GPIOA clock. */
rcc_periph_clock_enable(RCC_GPIOA);
/* Enable EXTI interrupt. */
nvic_enable_irq(NVIC_EXTI0_1_IRQ);
/* Set GPIO0 (in GPIO port A) to 'input float'. */
PORT_mode_setup(PPM, GPIO_MODE_INPUT, GPIO_PUPD_NONE);
/* Configure the EXTI subsystem. */
exti_select_source(EXTI0, GPIOA);
exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING);
exti_disable_request(EXTI0);
}
void max1168_arch_init( void ) {
/* configure external interrupt exti2 on PD2( data ready ) v1.0*/
/* PB2( data ready ) v1.1*/
/* 配置PD2为外部中断2（数据准备好）v1.0版*/
/* 配置PB2为外部中断2（数据准备好）v1.1版*/
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPBEN | RCC_APB2ENR_AFIOEN);//时钟使能
gpio_set_mode(GPIOB, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO2);//GPIO输入模式设定
//外部中断2的配置：触发模式，优先级，中断处理函数
exti_select_source(EXTI2, GPIOB);
exti_set_trigger(EXTI2, EXTI_TRIGGER_FALLING);
exti_enable_request(EXTI2);
nvic_set_priority(NVIC_EXTI2_IRQ, 0xF);
nvic_enable_irq(NVIC_EXTI2_IRQ);
}
void start_rht_read(void)
{
// First, move the pins up and down to get it going...
gpio_set_mode(PORT_RHT_IO, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, PIN_RHT_IO);
gpio_clear(PORT_RHT_IO, PIN_RHT_IO);
delay_ms(20); // docs say 1-10ms is enough....
gpio_set(PORT_RHT_IO, PIN_RHT_IO);
// want to wait for 40us here, but we're ok with letting some code delay us..
state.bitcount = 0;
state.seen_startbit = false;
state.rht_timeout = false;
nvic_enable_irq(RHT_NVIC);
// pull up will finish the job here for us.
gpio_set_mode(PORT_RHT_IO, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, PIN_RHT_IO);
exti_select_source(RHT_EXTI, PORT_RHT_IO);
exti_set_trigger(RHT_EXTI, EXTI_TRIGGER_FALLING);
exti_enable_request(RHT_EXTI);
setup_tim7();
}
void exti_setup(void)
{
/* Enable GPIOA clock. */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN);
/* Enable AFIO clock. */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN);
/* Enable EXTI0 interrupt. */
nvic_enable_irq(NVIC_EXTI0_IRQ);
/* Set GPIO0 (in GPIO port A) to 'input float'. */
gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO0);
/* Configure the EXTI subsystem. */
exti_select_source(EXTI0, GPIOA);
exti_set_trigger(EXTI0, EXTI_TRIGGER_BOTH);
exti_enable_request(EXTI0);
}
void ms2100_arch_init( void ) {
/* set mag reset as output (reset on PC13) ----*/
rcc_periph_clock_enable(RCC_GPIOC);
rcc_periph_clock_enable(RCC_AFIO);
gpio_set(GPIOC, GPIO13);
gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO13);
Ms2100Reset();
/* configure data ready input on PB5 */
rcc_periph_clock_enable(RCC_GPIOB);
gpio_set_mode(GPIOB, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO5);
/* external interrupt for drdy pin */
exti_select_source(EXTI5, GPIOB);
exti_set_trigger(EXTI5, EXTI_TRIGGER_RISING);
exti_enable_request(EXTI5);
nvic_set_priority(NVIC_EXTI9_5_IRQ, 0x0f);
nvic_enable_irq(NVIC_EXTI9_5_IRQ);
}
void play_file_fast_async(char *filename) {
//int i, j=0, k; //l, fn;
while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");}
vs1053_SCI_write(0x00, 0xc00);
while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");}
vs1053_SCI_write(SCI_VOL, 0x1010);
while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");}
iprintf("initial state 0x%04X\n", vs1053_SCI_read(SCI_CLOCKF));
while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");}
spi_set_baudrate_prescaler(CODEC_SPI, SPI_CR1_BR_FPCLK_DIV_256);
vs1053_SCI_write(SCI_CLOCKF, 0xF800);
spi_set_baudrate_prescaler(CODEC_SPI, SPI_CR1_BR_FPCLK_DIV_16);
while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");}
iprintf("after setup 0x%04X\n", vs1053_SCI_read(SCI_CLOCKF));
// while(!gpio_get(CODEC_CTRL, CODEC_DREQ)) {;}
// vs1053_SCI_write(SCI_CLOCKF, 0xA000);
// while(!gpio_get(CODEC_CTRL, CODEC_DREQ)) {;}
current_track.byte_count = 0;
current_track_playing = 1;
// now to set up the external interrupt on DREQ
// may need to trigger the first service in software too as we probably won't get an edge
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN);
nvic_enable_irq(NVIC_EXTI3_IRQ);
nvic_set_priority(NVIC_EXTI3_IRQ, 16);
exti_select_source(EXTI3, CODEC_DREQ_PORT);
exti_set_trigger(EXTI3, EXTI_TRIGGER_RISING);
exti_enable_request(EXTI3);
// generate a software interrupt to get this thing started as there shouldn't be any edges
sdfat_open_media(filename);
// iprintf("Generating software interrupt to start playback\r\n");
EXTI_SWIER |= EXTI3;
// exti3_isr();
}
void PPMin_Init()
{
#if _PWM_PIN == GPIO_USART1_TX
UART_Stop(); // disable USART1 for GPIO PA9 & PA10 (Trainer Tx(PA9) & Rx(PA10))
#endif
/* Enable GPIOA clock. */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN);
/* Enable AFIO clock. */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN);
/* Enable EXTI interrupt. */
nvic_enable_irq(NVIC_EXTI9_5_IRQ);
/* Set GPIO0 (in GPIO port A) to 'input float'. */
gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, _PWM_PIN);
/* Configure the EXTI subsystem. */
exti_select_source(_PWM_EXTI, GPIOA);
exti_set_trigger(_PWM_EXTI, EXTI_TRIGGER_RISING);
exti_disable_request(_PWM_EXTI);
}
void ROTARY_Init()
{
// This assumes all rotary pins are handled by the same interrupt
ctassert(ROTARY_PIN0.port == ROTARY_PIN1.port, All_rotary_pins_0_1_must_be_on_same_port);
ctassert(ROTARY_PIN0.port == ROTARY_PRESS_PIN.port, rotary_pins_0_ent_must_be_on_same_port);
ctassert(NVIC_EXTIx_IRQ(ROTARY_PIN0) == NVIC_EXTIx_IRQ(ROTARY_PIN1), rotary_pins_0_1_must_be_on_same_irq);
ctassert(NVIC_EXTIx_IRQ(ROTARY_PIN0) == NVIC_EXTIx_IRQ(ROTARY_PRESS_PIN), rotary_pins_0_ent_must_be_on_same_irq);
// All pins guaranteed to be on the same port
rcc_periph_clock_enable(get_rcc_from_pin(ROTARY_PIN0));
/*Rotary */
GPIO_setup_input(ROTARY_PIN0, ITYPE_PULLUP);
GPIO_setup_input(ROTARY_PIN1, ITYPE_PULLUP);
GPIO_setup_input(ROTARY_PRESS_PIN, ITYPE_PULLUP);
nvic_enable_irq(NVIC_EXTIx_IRQ(ROTARY_PIN0));
nvic_set_priority(NVIC_EXTIx_IRQ(ROTARY_PIN0), 66); // Medium priority
exti_select_source(EXTIx(ROTARY_PIN0) | EXTIx(ROTARY_PIN1), ROTARY_PIN0.port);
exti_set_trigger(EXTIx(ROTARY_PIN0) | EXTIx(ROTARY_PIN1), EXTI_TRIGGER_BOTH);
exti_enable_request(EXTIx(ROTARY_PIN0) | EXTIx(ROTARY_PIN1));
}
static int setup_rtc_wakeup(int period)
{
rtc_unlock();
/* ensure wakeup timer is off */
RTC_CR &= ~RTC_CR_WUTE;
/* Wait until we can write */
while ((RTC_ISR & RTC_ISR_WUTWF) == 0);
RTC_WUTR = period - 1;
/* Use the 1Hz clock as source */
RTC_CR &= ~(RTC_CR_WUCLKSEL_MASK << RTC_CR_WUCLKSEL_SHIFT);
RTC_CR |= (RTC_CR_WUCLKSEL_SPRE << RTC_CR_WUCLKSEL_SHIFT);
/* Restart WakeUp unit */
RTC_CR |= RTC_CR_WUTE;
/* interrupt configuration */
/* also, let's have an interrupt */
RTC_CR |= RTC_CR_WUTIE;
/* done with rtc registers, lock them again */
rtc_lock();
nvic_enable_irq(NVIC_RTC_WKUP_IRQ);
/* EXTI configuration */
/* Configure the EXTI subsystem. */
/* not needed, this chooses ports
exti_select_source(EXTI20, BUTTON_DISCO_USER_PORT);
*/
exti_set_trigger(EXTI20, EXTI_TRIGGER_RISING);
exti_enable_request(EXTI20);
return 0;
}
