void usbuart_init(void)
{
#if defined(BLACKMAGIC)
/* On mini hardware, UART and SWD share connector pins.
* Don't enable UART if we're being debugged. */
if ((platform_hwversion() == 1) && (SCS_DEMCR & SCS_DEMCR_TRCENA))
return;
#endif
rcc_periph_clock_enable(USBUSART_CLK);
UART_PIN_SETUP();
/* Setup UART parameters. */
usart_set_baudrate(USBUSART, 38400);
usart_set_databits(USBUSART, 8);
usart_set_stopbits(USBUSART, USART_STOPBITS_1);
usart_set_mode(USBUSART, USART_MODE_TX_RX);
usart_set_parity(USBUSART, USART_PARITY_NONE);
usart_set_flow_control(USBUSART, USART_FLOWCONTROL_NONE);
/* Finally enable the USART. */
usart_enable(USBUSART);
/* Enable interrupts */
USBUSART_CR1 |= USART_CR1_RXNEIE;
nvic_set_priority(USBUSART_IRQ, IRQ_PRI_USBUSART);
nvic_enable_irq(USBUSART_IRQ);
/* Setup timer for running deferred FIFO processing */
USBUSART_TIM_CLK_EN();
timer_reset(USBUSART_TIM);
timer_set_mode(USBUSART_TIM, TIM_CR1_CKD_CK_INT,
TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
timer_set_prescaler(USBUSART_TIM,
rcc_ppre2_frequency / USBUART_TIMER_FREQ_HZ * 2 - 1);
timer_set_period(USBUSART_TIM,
USBUART_TIMER_FREQ_HZ / USBUART_RUN_FREQ_HZ - 1);
/* Setup update interrupt in NVIC */
nvic_set_priority(USBUSART_TIM_IRQ, IRQ_PRI_USBUSART_TIM);
nvic_enable_irq(USBUSART_TIM_IRQ);
/* turn the timer on */
timer_enable_counter(USBUSART_TIM);
}
void imu_aspirin_arch_int_enable(void) {
#ifdef ASPIRIN_USE_GYRO_INT
nvic_set_priority(NVIC_EXTI15_10_IRQ, 0x0F);
nvic_enable_irq(NVIC_EXTI15_10_IRQ);
#endif
nvic_set_priority(NVIC_EXTI2_IRQ, 0x0F);
nvic_enable_irq(NVIC_EXTI2_IRQ);
// should not be needed anymore, handled by the spi driver
#if 0
/* Enable DMA1 channel4 IRQ Channel ( SPI RX) */
nvic_set_priority(NVIC_DMA1_CHANNEL4_IRQ, 0);
nvic_enable_irq(NVIC_DMA1_CHANNEL4_IRQ);
#endif
}
void i2c3_hw_init(void) {
i2c3.reg_addr = (void *)I2C3;
i2c3.init_struct = NULL;
i2c3.errors = &i2c3_errors;
i2c3.watchdog = -1;
/* zeros error counter */
ZEROS_ERR_COUNTER(i2c3_errors);
/* reset peripheral to default state ( sometimes not achieved on reset :( ) */
//rcc_periph_reset_pulse(RST_I2C3);
/* Configure and enable I2C3 event interrupt --------------------------------*/
nvic_set_priority(NVIC_I2C3_EV_IRQ, NVIC_I2C3_IRQ_PRIO);
nvic_enable_irq(NVIC_I2C3_EV_IRQ);
/* Configure and enable I2C3 err interrupt ----------------------------------*/
nvic_set_priority(NVIC_I2C3_ER_IRQ, NVIC_I2C3_IRQ_PRIO+1);
nvic_enable_irq(NVIC_I2C3_ER_IRQ);
/* Enable peripheral clocks -------------------------------------------------*/
/* Enable I2C3 clock */
rcc_periph_clock_enable(RCC_I2C3);
/* setup gpio clock and pins */
i2c_setup_gpio(I2C3);
rcc_periph_reset_pulse(RST_I2C3);
// enable peripheral
i2c_peripheral_enable(I2C3);
/*
* XXX: there is a function to do that already in libopencm3 but I am not
* sure if it is correct, using direct register instead (esden)
*/
//i2c_set_own_7bit_slave_address(I2C3, 0);
I2C_OAR1(I2C3) = 0 | 0x4000;
// enable error interrupts
i2c_enable_interrupt(I2C3, I2C_CR2_ITERREN);
i2c_setbitrate(&i2c3, I2C3_CLOCK_SPEED);
}
void can_setup(void)
{
/* Enable peripheral clocks. */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN);
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_CANEN);
/* Configure CAN pin: RX (input pull-up). */
gpio_set_mode(GPIOA, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_CAN_RX);
gpio_set(GPIOA, GPIO_CAN_RX);
/* Configure CAN pin: TX. */
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_CAN_TX);
/* NVIC setup. */
nvic_enable_irq(NVIC_USB_LP_CAN_RX0_IRQ);
nvic_set_priority(NVIC_USB_LP_CAN_RX0_IRQ, 1);
/* Reset CAN. */
can_reset(CAN1);
/* CAN cell init. */
if (can_init(CAN1,
false, /* TTCM: Time triggered comm mode? */
true, /* ABOM: Automatic bus-off management? */
false, /* AWUM: Automatic wakeup mode? */
false, /* NART: No automatic retransmission? */
false, /* RFLM: Receive FIFO locked mode? */
false, /* TXFP: Transmit FIFO priority? */
CAN_BTR_SJW_1TQ,
CAN_BTR_TS1_3TQ,
CAN_BTR_TS2_4TQ,
12)) /* BRP+1: Baud rate prescaler */
{
gpio_set(GPIOA, GPIO6); /* LED0 off */
gpio_set(GPIOA, GPIO7); /* LED1 off */
gpio_set(GPIOB, GPIO0); /* LED2 off */
gpio_clear(GPIOB, GPIO1); /* LED3 on */
/* Die because we failed to initialize. */
while (1)
__asm__("nop");
}
/* CAN filter 0 init. */
can_filter_id_mask_32bit_init(CAN1,
0, /* Filter ID */
0, /* CAN ID */
0, /* CAN ID mask */
0, /* FIFO assignment (here: FIFO0) */
true); /* Enable the filter. */
/* Enable CAN RX interrupt. */
can_enable_irq(CAN1, CAN_IER_FMPIE0);
}
void baro_init()
{
gpio_set_mode(GPIOB, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO14);
gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO13 | GPIO15);
gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_PUSHPULL, GPIO12);
deselect_slave();
spi_init_master(SPI2, SPI_CR1_BAUDRATE_FPCLK_DIV_8, SPI_CR1_CPOL,
SPI_CR1_CPHA, SPI_CR1_DFF_8BIT, SPI_CR1_MSBFIRST);
spi_enable_ss_output(SPI2);
spi_enable(SPI2);
dma_set_peripheral_address(DMA1, DMA_CHANNEL3, SPI2_DR);
dma_set_read_from_memory(DMA1, DMA_CHANNEL3);
dma_enable_memory_increment_mode(DMA1, DMA_CHANNEL3);
dma_set_peripheral_size(DMA1, DMA_CHANNEL3, DMA_CCR_PSIZE_8BIT);
dma_set_memory_size(DMA1, DMA_CHANNEL3, DMA_CCR_MSIZE_8BIT);
dma_set_priority(DMA1, DMA_CHANNEL3, DMA_CCR_PL_HIGH);
dma_set_peripheral_address(DMA1, DMA_CHANNEL4, SPI2_DR);
dma_set_read_from_peripheral(DMA1, DMA_CHANNEL4);
dma_enable_memory_increment_mode(DMA1, DMA_CHANNEL4);
dma_set_peripheral_size(DMA1, DMA_CHANNEL4, DMA_CCR_PSIZE_8BIT);
dma_set_memory_size(DMA1, DMA_CHANNEL4, DMA_CCR_MSIZE_8BIT);
dma_set_priority(DMA1, DMA_CHANNEL4, DMA_CCR_PL_VERY_HIGH);
dma_enable_transfer_complete_interrupt(DMA1, DMA_CHANNEL4);
timer_reset(TIM4);
timer_enable_irq(TIM4, TIM_DIER_UIE);
timer_set_mode(TIM4, TIM_CR1_CKD_CK_INT,
TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
/* 3200 / 16 = 200 Hz */
timer_set_prescaler(TIM4, 32);
timer_set_period(TIM4, 5625);
nvic_set_priority(NVIC_TIM4_IRQ, 16 * 2);
nvic_set_priority(NVIC_DMA1_CHANNEL4_IRQ, 16 * 2);
nvic_enable_irq(NVIC_TIM4_IRQ);
nvic_enable_irq(NVIC_DMA1_CHANNEL4_IRQ);
read_calibration_data();
}
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");
// }
}
/** PWM arch init called by generic pwm driver
*/
void actuators_dualpwm_arch_init(void)
{
/*-----------------------------------
* Configure timer peripheral clocks
*-----------------------------------*/
#if PWM_USE_TIM1
rcc_periph_clock_enable(RCC_TIM1);
#endif
#if PWM_USE_TIM2
rcc_periph_clock_enable(RCC_TIM2);
#endif
#if PWM_USE_TIM3
rcc_periph_clock_enable(RCC_TIM3);
#endif
#if PWM_USE_TIM4
rcc_periph_clock_enable(RCC_TIM4);
#endif
#if PWM_USE_TIM5
rcc_periph_clock_enable(RCC_TIM5);
#endif
#if PWM_USE_TIM8
rcc_periph_clock_enable(RCC_TIM8);
#endif
#if PWM_USE_TIM9
rcc_periph_clock_enable(RCC_TIM9);
#endif
#if PWM_USE_TIM12
rcc_periph_clock_enable(RCC_TIM12);
#endif
/*----------------
* Configure GPIO
*----------------*/
#ifdef DUAL_PWM_SERVO_5
gpio_setup_pin_af(DUAL_PWM_SERVO_5_GPIO, DUAL_PWM_SERVO_5_PIN, DUAL_PWM_SERVO_5_AF, TRUE);
#endif
#ifdef DUAL_PWM_SERVO_6
gpio_setup_pin_af(DUAL_PWM_SERVO_6_GPIO, DUAL_PWM_SERVO_6_PIN, DUAL_PWM_SERVO_6_AF, TRUE);
#endif
#if DUAL_PWM_USE_TIM5
set_servo_timer(TIM5, TIM5_SERVO_HZ, PWM_TIM5_CHAN_MASK);
nvic_set_priority(NVIC_TIM5_IRQ, 2);
nvic_enable_irq(NVIC_TIM5_IRQ);
timer_enable_irq(TIM5, TIM_DIER_CC1IE);
#endif
//calculation the values to put into the timer registers to generate pulses every 4ms and 16ms.
ratio_4ms = (ONE_MHZ_CLK / 250) - 1;
ratio_16ms = (ONE_MHZ_CLK / 62.5) - 1;
}
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);
}
void cdcacm_init(void) {
//system setup
rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);
gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE,
GPIO9 | GPIO11 | GPIO12);
gpio_set_af(GPIOA, GPIO_AF10, GPIO9 | GPIO11 | GPIO12);
cdcacm_usb_init();
nvic_set_priority(NVIC_OTG_FS_IRQ, IRQ_PRI_USB);
nvic_enable_irq(NVIC_OTG_FS_IRQ);
while (cdcacm_get_config() != 1) { wait(1); }; //wait until usb is configured
}
static void can_setup(void) {
/* Enable peripheral clocks */
rcc_periph_clock_enable(RCC_AFIO);
rcc_periph_clock_enable(RCC_CAN1);
AFIO_MAPR |= AFIO_MAPR_CAN1_REMAP_PORTB;
/* Configure CAN pin: RX (input pull-up) */
gpio_set_mode(GPIO_BANK_CAN1_PB_RX, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_CAN1_PB_RX);
gpio_set(GPIO_BANK_CAN1_PB_RX, GPIO_CAN1_PB_RX);
/* Configure CAN pin: TX */
gpio_set_mode(GPIO_BANK_CAN1_PB_TX, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_CAN1_PB_TX);
/* NVIC setup */
nvic_enable_irq(NVIC_USB_LP_CAN_RX0_IRQ);
nvic_set_priority(NVIC_USB_LP_CAN_RX0_IRQ, 1);
/* Reset CAN */
can_reset(CAN1);
/* CAN cell init.
* Setting the bitrate to 250kHz. APB1 = 36MHz,
* prescaler = 9 -> 4MHz time quanta frequency.
* 1tq sync + 9tq bit segment1 (TS1) + 6tq bit segment2 (TS2) =
* 16time quanto per bit period, therefor 4MHz/16 = 250kHz
*/
if (can_init(CAN1, false, /* TTCM: Time triggered comm mode? */
true, /* ABOM: Automatic bus-off management? */
false, /* AWUM: Automatic wakeup mode? */
false, /* NART: No automatic retransmission? */
false, /* RFLM: Receive FIFO locked mode? */
false, /* TXFP: Transmit FIFO priority? */
CAN_BTR_SJW_1TQ, CAN_BTR_TS1_9TQ, CAN_BTR_TS2_6TQ, 9, false, false)) {
gpio_clear(GPIOC, GPIO13); /* LED green on */
/* Die because we failed to initialize. */
while (1)
__asm__("nop");
}
/* CAN filter 0 init. */
can_filter_id_mask_32bit_init(CAN1, 0, /* Filter ID */
0, /* CAN ID */
0, /* CAN ID mask */
0, /* FIFO assignment (here: FIFO0) */
true); /* Enable the filter. */
/* Enable CAN RX interrupt. */
can_enable_irq(CAN1, CAN_IER_FMPIE0);
}
void UART_Initialize()
{
/* Enable clocks for GPIO port containing _USART and USART */
rcc_peripheral_enable_clock(&_USART_RCC_APB_ENR_IOP, _USART_RCC_APB_ENR_IOP_EN);
rcc_peripheral_enable_clock(&_USART_RCC_APB_ENR_USART, _USART_RCC_APB_ENR_USART_EN);
/* Enable DMA clock */
// TODO ENABLED ALREADY FOR ADC?
rcc_peripheral_enable_clock(&RCC_AHBENR, _RCC_AHBENR_DMAEN);
/* Setup GPIO pin GPIO_USARTX_TX on USART GPIO port for transmit. */
gpio_set_mode(_USART_GPIO, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, _USART_GPIO_USART_TX);
//gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT,
//GPIO_USART1_RX);
/* Setup UART parameters. */
usart_set_baudrate(_USART, 115200);
usart_set_databits(_USART, 8);
usart_set_stopbits(_USART, USART_STOPBITS_1);
usart_set_mode(_USART, USART_MODE_TX);
usart_set_parity(_USART, USART_PARITY_NONE);
usart_set_flow_control(_USART, USART_FLOWCONTROL_NONE);
//usart_set_mode(USART1, USART_MODE_TX_RX);
/* Finally enable the USART. */
usart_enable(_USART);
nvic_set_priority(_USART_NVIC_DMA_CHANNEL_IRQ, 3);
nvic_enable_irq(_USART_NVIC_DMA_CHANNEL_IRQ);
#if HAS_AUDIO_UART5
/* Enable clocks for GPIO port C (for GPIO_UART5_TX) and UART5. */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN);
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART5EN);
/* Setup GPIO pins to use UART5 */
gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_UART5_TX);
/* Setup UART5 parameters. */
usart_set_baudrate(UART5, 9600);
usart_set_databits(UART5, 8);
usart_set_stopbits(UART5, USART_STOPBITS_1);
usart_set_parity(UART5, USART_PARITY_NONE);
usart_set_mode(UART5, USART_MODE_TX);
/* Finally enable the UART5. */
usart_enable(UART5);
#endif
}
/** @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
}
/**
* Callback from your main program to set up the board's hardware before
* the kernel is started.
*/
int board_setup(void)
{
/* Disable interrupts. This makes sure that the sys_tick_handler will
* not be called before the first thread has been started.
* Interrupts will be enabled by archFirstThreadRestore().
*/
cm_mask_interrupts(true);
/* configure system clock, user LED and UART */
clock_setup();
test_led_setup();
usart_setup(57600);
/* initialise SysTick counter */
systick_setup();
/* Set exception priority levels. Make PendSv the lowest priority and
* SysTick the second to lowest
*/
nvic_set_priority(NVIC_PENDSV_IRQ, 0xFF);
nvic_set_priority(NVIC_SYSTICK_IRQ, 0xFE);
return 0;
}
static void bluetooth_setup(void){
printf("\nBluetooth starting...\n");
// n_shutdown as output
gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,GPIO_BT_N_SHUTDOWN);
// tx output
gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART3_TX);
// rts output (default to 1)
gpio_set(GPIOB, GPIO_USART3_RTS);
gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART3_RTS);
// rx input
gpio_set_mode(GPIOB, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_USART3_RX);
// cts as input
gpio_set_mode(GPIOB, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_USART3_CTS);
/* Setup UART parameters. */
usart_set_baudrate(USART3, 115200);
usart_set_databits(USART3, 8);
usart_set_stopbits(USART3, USART_STOPBITS_1);
usart_set_mode(USART3, USART_MODE_TX_RX);
usart_set_parity(USART3, USART_PARITY_NONE);
usart_set_flow_control(USART3, USART_FLOWCONTROL_RTS);
/* Finally enable the USART. */
usart_enable(USART3);
// TX
nvic_set_priority(NVIC_DMA1_CHANNEL2_IRQ, 0);
nvic_enable_irq(NVIC_DMA1_CHANNEL2_IRQ);
// RX
nvic_set_priority(NVIC_DMA1_CHANNEL3_IRQ, 0);
nvic_enable_irq(NVIC_DMA1_CHANNEL3_IRQ);
}
void usb_init(void)
{
usb_queue_init(&usb_endpoint_control_in_queue);
usb_queue_init(&usb_endpoint_control_out_queue);
usb_queue_init(&usb_endpoint_bulk_cmd_in_queue);
usb_queue_init(&usb_endpoint_bulk_cmd_out_queue);
usb_queue_init(&usb_endpoint_bulk_data_in_queue);
usb_set_configuration_changed_cb(usb_configuration_changed);
usb_peripheral_reset();
usb_device_init(0, &usb_device);
usb_endpoint_init(&usb_endpoint_control_out);
usb_endpoint_init(&usb_endpoint_control_in);
nvic_set_priority(NVIC_USB0_IRQ, 255);
usb_run(&usb_device);
}
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 rtc_init(void)
{
/*
* If the RTC is pre-configured just allow access, don't reconfigure.
* Otherwise enable it with the LSE as clock source and 0x7fff as
* prescale value.
*/
rtc_auto_awake(LSE, 0x7fff);
/* Without this the RTC interrupt routine will never be called. */
nvic_enable_irq(NVIC_RTC_IRQ);
nvic_set_priority(NVIC_RTC_IRQ, 1);
/* Enable the RTC interrupt to occur off the SEC flag. */
rtc_interrupt_enable(RTC_SEC);
}
void UART_Initialize()
{
/* Enable clocks for GPIO port containing _USART and USART */
rcc_periph_clock_enable(get_rcc_from_port(UART_CFG.uart));
rcc_periph_clock_enable(get_rcc_from_pin(UART_CFG.rx));
rcc_periph_clock_enable(get_rcc_from_pin(UART_CFG.tx));
/* Enable DMA clock */
rcc_periph_clock_enable(get_rcc_from_port(USART_DMA.dma));
/* Setup GPIO pin GPIO_USARTX_TX on USART GPIO port for transmit.
Set normal function to input as this is mode reverted to in half-duplex receive */
GPIO_setup_input(UART_CFG.rx, ITYPE_FLOAT);
GPIO_setup_output_af(UART_CFG.tx, OTYPE_PUSHPULL, UART_CFG.uart);
/* Setup UART parameters. */
UART_SetDataRate(0);
UART_SetFormat(8, UART_PARITY_NONE, UART_STOPBITS_1);
UART_SetDuplex(UART_DUPLEX_FULL);
usart_set_flow_control(UART_CFG.uart, USART_FLOWCONTROL_NONE);
usart_set_mode(UART_CFG.uart, USART_MODE_TX_RX);
/* Finally enable the USART. */
usart_enable(UART_CFG.uart);
nvic_set_priority(get_nvic_dma_irq(USART_DMA), 3);
nvic_enable_irq(get_nvic_dma_irq(USART_DMA));
#if HAS_AUDIO_UART
/* Enable clocks for GPIO port C (for GPIO_UART5_TX) and UART5. */
rcc_periph_clock_enable(get_rcc_from_port(AUDIO_UART_CFG.uart));
rcc_periph_clock_enable(get_rcc_from_pin(AUDIO_UART_CFG.tx));
/* Setup GPIO pins to use UART5 */
GPIO_setup_output_af(AUDIO_UART_CFG.tx, OTYPE_PUSHPULL, AUDIO_UART_CFG.uart);
/* Setup UART5 parameters. */
usart_set_baudrate(AUDIO_UART_CFG.uart, 9600);
usart_set_databits(AUDIO_UART_CFG.uart, 8);
usart_set_stopbits(AUDIO_UART_CFG.uart, USART_STOPBITS_1);
usart_set_parity(AUDIO_UART_CFG.uart, USART_PARITY_NONE);
usart_set_mode(AUDIO_UART_CFG.uart, USART_MODE_TX);
/* Finally enable the AUDIO_UART_CFG.uart. */
usart_enable(AUDIO_UART_CFG.uart);
#endif
}
static void platform_init_eventtimer() {
/* Set up TIM2 as 32bit clock */
timer_reset(TIM2);
timer_set_mode(TIM2, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
timer_set_period(TIM2, 0xFFFFFFFF);
timer_set_prescaler(TIM2, 0);
timer_disable_preload(TIM2);
timer_continuous_mode(TIM2);
/* Setup output compare registers */
timer_disable_oc_output(TIM2, TIM_OC1);
timer_disable_oc_output(TIM2, TIM_OC2);
timer_disable_oc_output(TIM2, TIM_OC3);
timer_disable_oc_output(TIM2, TIM_OC4);
timer_disable_oc_clear(TIM2, TIM_OC1);
timer_disable_oc_preload(TIM2, TIM_OC1);
timer_set_oc_slow_mode(TIM2, TIM_OC1);
timer_set_oc_mode(TIM2, TIM_OC1, TIM_OCM_FROZEN);
/* Setup input captures for CH2-4 Triggers */
gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO3);
gpio_set_af(GPIOB, GPIO_AF1, GPIO3);
timer_ic_set_input(TIM2, TIM_IC2, TIM_IC_IN_TI2);
timer_ic_set_filter(TIM2, TIM_IC2, TIM_IC_CK_INT_N_2);
timer_ic_set_polarity(TIM2, TIM_IC2, TIM_IC_FALLING);
timer_ic_enable(TIM2, TIM_IC2);
gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO10);
gpio_set_af(GPIOB, GPIO_AF1, GPIO10);
timer_ic_set_input(TIM2, TIM_IC3, TIM_IC_IN_TI3);
timer_ic_set_filter(TIM2, TIM_IC3, TIM_IC_CK_INT_N_2);
timer_ic_set_polarity(TIM2, TIM_IC3, TIM_IC_FALLING);
timer_ic_enable(TIM2, TIM_IC3);
gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO11);
gpio_set_af(GPIOB, GPIO_AF1, GPIO11);
timer_ic_set_input(TIM2, TIM_IC4, TIM_IC_IN_TI4);
timer_ic_set_filter(TIM2, TIM_IC4, TIM_IC_CK_INT_N_2);
timer_ic_set_polarity(TIM2, TIM_IC4, TIM_IC_FALLING);
timer_ic_enable(TIM2, TIM_IC4);
timer_enable_counter(TIM2);
timer_enable_irq(TIM2, TIM_DIER_CC2IE);
timer_enable_irq(TIM2, TIM_DIER_CC3IE);
timer_enable_irq(TIM2, TIM_DIER_CC4IE);
nvic_enable_irq(NVIC_TIM2_IRQ);
nvic_set_priority(NVIC_TIM2_IRQ, 0);
}
/**
* @brief Initializes the AEAT9000 SSI Link
* @param u16 clk_speed SSI Clock Speed in 100bps LSB units
*/
void ssi_initialize(u16 clk_speed)
{
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_TIM2EN); // Initialize timer clk
// Initialize I/O Pins
gpio_set_mode(SSI_GPIO, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, SSI_CLK_PIN);
gpio_set_mode(SSI_GPIO, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, SSI_DATA_PIN);
gpio_set_mode(SSI_GPIO, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, SSI_NCS_PIN);
// Initialize clock timer on TIM1
TIM_DIER(SSI_TIMER) = TIM_DIER_UIE;
TIM_PSC(SSI_TIMER) = 1; // 24MHz Clock
TIM_ARR(SSI_TIMER) = TIMER_MAX; // Update at 500kHz
// Initialize NVIC
nvic_enable_irq(NVIC_TIM2_IRQ);
nvic_set_priority(NVIC_TIM2_IRQ, 1);
ssi_state = SSI_IDLE;
ssi_data_ready_flag = false;
}
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 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 LED_init(void)
{
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_TIM2EN);
set_led(false);
timer_reset(TIM2);
timer_set_mode(TIM2, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
timer_set_prescaler(TIM2, 256);
timer_enable_preload(TIM2);
timer_one_shot_mode(TIM2);
timer_set_period(TIM2, (uint16_t)((rcc_ppre1_frequency/256) / 20));
timer_enable_irq(TIM2, TIM_DIER_UIE);
timer_clear_flag(TIM2, TIM_SR_UIF);
nvic_enable_irq(NVIC_TIM2_IRQ);
nvic_set_priority(NVIC_TIM2_IRQ, 128);
}
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 timer_setup(void)
{
rcc_periph_clock_enable(RCC_TIM2);
nvic_enable_irq(NVIC_TIM2_IRQ);
nvic_set_priority(NVIC_TIM2_IRQ, 1);
timer_reset(TIM2);
/* Timer global mode: - No Divider, Alignment edge, Direction up */
timer_set_mode(TIM2, TIM_CR1_CKD_CK_INT,
TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
timer_continuous_mode(TIM2);
/* Set timer prescaler. 72MHz/1440 => 50000 counts per second. */
timer_set_prescaler(TIM2, 1440);
/* End timer value. When this is reached an interrupt is generated. */
timer_set_period(TIM2, BLINK_INTERVAL);
/* Update interrupt enable. */
timer_enable_irq(TIM2, TIM_DIER_UIE);
/* Start timer. */
timer_enable_counter(TIM2);
}
void uart_init(int baud)
{
uart_init_gpio();
nvic_enable_irq(NVIC_USART1_IRQ);
nvic_set_priority(NVIC_USART1_IRQ, 2);
usart_set_baudrate(USART1, baud);
usart_set_databits(USART1, 8);
usart_set_parity(USART1, USART_PARITY_NONE);
usart_set_flow_control(USART1, USART_FLOWCONTROL_NONE);
usart_set_stopbits(USART1, USART_CR2_STOPBITS_1);
usart_set_mode(USART1, USART_MODE_TX_RX);
usart_enable_rx_interrupt(USART1);
usart_enable(USART1);
/* This ensures stdio doesn't use its own buffers */
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
}
void traceswo_init(void)
{
periph_clock_enable(RCC_GPIOD);
periph_clock_enable(TRACEUART_CLK);
__asm__("nop"); __asm__("nop"); __asm__("nop");
gpio_mode_setup(SWO_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, SWO_PIN);
gpio_set_af(SWO_PORT, 1, SWO_PIN); /* U2RX */
uart_disable(TRACEUART);
/* Setup UART parameters. */
uart_clock_from_sysclk(TRACEUART);
uart_set_baudrate(TRACEUART, 800000);
uart_set_databits(TRACEUART, 8);
uart_set_stopbits(TRACEUART, 1);
uart_set_parity(TRACEUART, UART_PARITY_NONE);
// Enable FIFO
uart_enable_fifo(TRACEUART);
// Set FIFO interrupt trigger levels to 4/8 full for RX buffer and
// 7/8 empty (1/8 full) for TX buffer
uart_set_fifo_trigger_levels(TRACEUART, UART_FIFO_RX_TRIG_1_2, UART_FIFO_TX_TRIG_7_8);
uart_clear_interrupt_flag(TRACEUART, UART_INT_RX | UART_INT_RT);
/* Enable interrupts */
uart_enable_interrupts(TRACEUART, UART_INT_RX | UART_INT_RT);
/* Finally enable the USART. */
uart_enable(TRACEUART);
nvic_set_priority(TRACEUART_IRQ, 0);
nvic_enable_irq(TRACEUART_IRQ);
/* Un-stall USB endpoint */
usbd_ep_stall_set(usbdev, 0x85, 0);
gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO3);
}
static void platform_init_usart() {
/* USART initialization */
nvic_enable_irq(NVIC_USART1_IRQ);
nvic_set_priority(NVIC_USART1_IRQ, 64);
gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO6);
gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO7);
gpio_set_output_options(GPIOB, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, GPIO7);
/* Setup USART1 TX and RX pin as alternate function. */
gpio_set_af(GPIOB, GPIO_AF7, GPIO6);
gpio_set_af(GPIOB, GPIO_AF7, GPIO7);
/* Setup USART2 parameters. */
usart_set_baudrate(USART1, config.console.baud);
usart_set_databits(USART1, config.console.data_bits);
switch (config.console.stop_bits) {
case 1:
usart_set_stopbits(USART1, USART_STOPBITS_1);
break;
default:
while (1);
}
usart_set_mode(USART1, USART_MODE_TX_RX);
switch (config.console.parity) {
case 'N':
usart_set_parity(USART1, USART_PARITY_NONE);
break;
case 'O':
usart_set_parity(USART1, USART_PARITY_ODD);
break;
case 'E':
usart_set_parity(USART1, USART_PARITY_EVEN);
break;
}
usart_set_flow_control(USART1, USART_FLOWCONTROL_NONE);
/* Finally enable the USART. */
usart_enable(USART1);
usart_rx_reset();
}
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);
}
