void uart3_init( void ) {
uart_periph_init(&uart3);
uart3.reg_addr = USART3;
/* init RCC */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(UART3_Periph, ENABLE);
/* Enable USART3 interrupts */
usart_enable_irq(USART3_IRQn);
/* Init GPIOS */
GPIO_PinRemapConfig(GPIO_PartialRemap_USART3, ENABLE);
GPIO_InitTypeDef gpio;
/* GPIOC: GPIO_Pin_10 USART3 Tx push-pull */
gpio.GPIO_Pin = UART3_TxPin;
gpio.GPIO_Mode = GPIO_Mode_AF_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(UART3_TxPort, &gpio);
/* GPIOC: GPIO_Pin_11 USART3 Rx pin as floating input */
gpio.GPIO_Pin = UART3_RxPin;
gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(UART3_RxPort, &gpio);
/* Configure USART3 */
uart_periph_set_baudrate(&uart3, UART3_BAUD);
}
void uart1_init( void ) {
uart_periph_init(&uart1);
uart1.reg_addr = USART1;
/* init RCC */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
RCC_APB2PeriphClockCmd(UART1_Periph, ENABLE);
/* Enable USART1 interrupts */
usart_enable_irq(USART1_IRQn);
/* Init GPIOS */
GPIO_InitTypeDef gpio;
/* GPIOA: GPIO_Pin_9 USART1 Tx push-pull */
gpio.GPIO_Pin = UART1_TxPin;
gpio.GPIO_Mode = GPIO_Mode_AF_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(UART1_TxPort, &gpio);
/* GPIOA: GPIO_Pin_10 USART1 Rx pin as floating input */
gpio.GPIO_Pin = UART1_RxPin;
gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(UART1_RxPort, &gpio);
/* Configure USART1 */
uart_periph_set_baudrate(&uart1, UART1_BAUD);
}
void uart2_init( void ) {
uart_periph_init(&uart2);
uart2.reg_addr = USART2;
/* init RCC */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_APB2PeriphClockCmd(UART2_Periph, ENABLE);
/* Enable USART2 interrupts */
usart_enable_irq(USART2_IRQn);
/* Init GPIOS */
GPIO_InitTypeDef gpio;
/* GPIOA: GPIO_Pin_2 USART2 Tx push-pull */
gpio.GPIO_Pin = UART2_TxPin; // ;
gpio.GPIO_Mode = GPIO_Mode_AF_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(UART2_TxPort, &gpio);
/* GPIOA: GPIO_Pin_3 USART2 Rx pin as floating input */
gpio.GPIO_Pin = UART2_RxPin; // ;
gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(UART2_RxPort, &gpio);
/* Configure USART2 */
uart_periph_set_baudrate(&uart2, UART2_BAUD);
}
void uart5_init( void ) {
uart_periph_init(&uart5);
uart5.reg_addr = (void *)UART5;
/* init RCC and GPIOs */
#if defined(STM32F4)
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART5EN);
set_uart_pin(UART5_GPIO_PORT_RX, UART5_GPIO_RX, UART5_GPIO_AF);
set_uart_pin(UART5_GPIO_PORT_TX, UART5_GPIO_TX, UART5_GPIO_AF);
#elif defined(STM32F1)
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART5EN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPDEN);
gpio_set_mode(GPIO_BANK_UART5_TX, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_UART5_TX);
gpio_set_mode(GPIO_BANK_UART5_RX, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO_UART5_RX);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_UART5_IRQ);
/* Configure USART */
uart_periph_set_mode(&uart5, USE_UART5_TX, USE_UART5_RX, FALSE);
uart_periph_set_baudrate(&uart5, UART5_BAUD);
}
void uart1_init(void)
{
uart_periph_init(&uart1);
uart1.reg_addr = (void *)USART1;
/* init RCC and GPIOs */
rcc_periph_clock_enable(RCC_USART1);
#if USE_UART1_TX
gpio_setup_pin_af(UART1_GPIO_PORT_TX, UART1_GPIO_TX, UART1_GPIO_AF, TRUE);
#endif
#if USE_UART1_RX
gpio_setup_pin_af(UART1_GPIO_PORT_RX, UART1_GPIO_RX, UART1_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART1_IRQ);
#if UART1_HW_FLOW_CONTROL
#warning "USING UART1 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS gpios */
gpio_setup_pin_af(UART1_GPIO_PORT_CTS, UART1_GPIO_CTS, UART1_GPIO_AF, FALSE);
gpio_setup_pin_af(UART1_GPIO_PORT_RTS, UART1_GPIO_RTS, UART1_GPIO_AF, TRUE);
#endif
/* Configure USART1, enable hardware flow control*/
uart_periph_set_mode(&uart1, USE_UART1_TX, USE_UART1_RX, UART1_HW_FLOW_CONTROL);
/* Set USART1 parameters and enable interrupt */
uart_periph_set_bits_stop_parity(&uart1, UART1_BITS, UART1_STOP, UART1_PARITY);
uart_periph_set_baudrate(&uart1, UART1_BAUD);
}
void uart2_init(void)
{
uart_periph_init(&uart2);
uart2.reg_addr = (void *)USART2;
/* init RCC and GPIOs */
rcc_periph_clock_enable(RCC_USART2);
#if USE_UART2_TX
gpio_setup_pin_af(UART2_GPIO_PORT_TX, UART2_GPIO_TX, UART2_GPIO_AF, TRUE);
#endif
#if USE_UART2_RX
gpio_setup_pin_af(UART2_GPIO_PORT_RX, UART2_GPIO_RX, UART2_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART2_IRQ);
#if UART2_HW_FLOW_CONTROL && defined(STM32F4)
#warning "USING UART2 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS pins */
gpio_setup_pin_af(UART2_GPIO_PORT_CTS, UART2_GPIO_CTS, UART2_GPIO_AF, FALSE);
gpio_setup_pin_af(UART2_GPIO_PORT_RTS, UART2_GPIO_RTS, UART2_GPIO_AF, TRUE);
#endif
/* Configure USART Tx,Rx, and hardware flow control*/
uart_periph_set_mode(&uart2, USE_UART2_TX, USE_UART2_RX, UART2_HW_FLOW_CONTROL);
/* Configure USART */
uart_periph_set_bits_stop_parity(&uart2, UART2_BITS, UART2_STOP, UART2_PARITY);
uart_periph_set_baudrate(&uart2, UART2_BAUD);
}
void uart3_init( void ) {
uart_periph_init(&uart3);
uart3.reg_addr = (void *)USART3;
/* init RCC */
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART3EN);
#if USE_UART3_TX
gpio_setup_pin_af(UART3_GPIO_PORT_TX, UART3_GPIO_TX, UART3_GPIO_AF, TRUE);
#endif
#if USE_UART3_RX
gpio_setup_pin_af(UART3_GPIO_PORT_RX, UART3_GPIO_RX, UART3_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART3_IRQ);
#if UART3_HW_FLOW_CONTROL && defined(STM32F4)
#warning "USING UART3 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS pins */
gpio_setup_pin_af(UART3_GPIO_PORT_CTS, UART3_GPIO_CTS, UART3_GPIO_AF, FALSE);
gpio_setup_pin_af(UART3_GPIO_PORT_RTS, UART3_GPIO_RTS, UART3_GPIO_AF, TRUE);
#endif
/* Configure USART Tx,Rx, and hardware flow control*/
uart_periph_set_mode(&uart3, USE_UART3_TX, USE_UART3_RX, UART3_HW_FLOW_CONTROL);
/* Configure USART */
uart_periph_set_baudrate(&uart3, UART3_BAUD);
}
void uart6_init( void ) {
uart_periph_init(&uart6);
uart6.reg_addr = (void *)USART6;
/* enable uart clock */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_USART6EN);
/* init RCC and GPIOs */
#if USE_UART6_TX
gpio_setup_pin_af(UART6_GPIO_PORT_TX, UART6_GPIO_TX, UART6_GPIO_AF, TRUE);
#endif
#if USE_UART6_RX
gpio_setup_pin_af(UART6_GPIO_PORT_RX, UART6_GPIO_RX, UART6_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART6_IRQ);
#if UART6_HW_FLOW_CONTROL
#warning "USING UART6 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS pins */
gpio_setup_pin_af(UART6_GPIO_PORT_CTS, UART6_GPIO_CTS, UART6_GPIO_AF, FALSE);
gpio_setup_pin_af(UART6_GPIO_PORT_RTS, UART6_GPIO_RTS, UART6_GPIO_AF, TRUE);
#endif
/* Configure USART Tx,Rx and hardware flow control*/
uart_periph_set_mode(&uart6, USE_UART6_TX, USE_UART6_RX, UART6_HW_FLOW_CONTROL);
uart_periph_set_baudrate(&uart6, UART6_BAUD);
}
void uart5_init( void ) {
uart_periph_init(&uart5);
uart5.reg_addr = USART5;
/* init RCC */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE);
RCC_APB2PeriphClockCmd(UART5_PeriphTx, ENABLE);
RCC_APB2PeriphClockCmd(UART5_PeriphRx, ENABLE);
/* Enable UART5 interrupts */
usart_enable_irq(UART5_IRQn);
/* Init GPIOS */
GPIO_InitTypeDef gpio;
/* GPIOC: GPIO_Pin_10 UART5 Tx push-pull */
gpio.GPIO_Pin = UART5_TxPin;
gpio.GPIO_Mode = GPIO_Mode_AF_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(UART5_TxPort, &gpio);
/* GPIOC: GPIO_Pin_11 UART5 Rx pin as floating input */
gpio.GPIO_Pin = UART5_RxPin;
gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(UART5_RxPort, &gpio);
/* Configure UART5 */
uart_periph_set_baudrate(&uart5, UART5_BAUD);
}
static void checkPx4RebootCommand(uint8_t b)
{
if (intermcu.stable_px4_baud == CHANGING_BAUD && sys_time_check_and_ack_timer(px4bl_tid)) {
//to prevent a short intermcu comm loss, give some time to changing the baud
sys_time_cancel_timer(px4bl_tid);
intermcu.stable_px4_baud = PPRZ_BAUD;
} else if (intermcu.stable_px4_baud == PX4_BAUD) {
if (sys_time_check_and_ack_timer(px4bl_tid)) {
//time out the possibility to reboot to the px4 bootloader, to prevent unwanted restarts during flight
sys_time_cancel_timer(px4bl_tid);
//for unknown reasons, 1500000 baud does not work reliably after prolonged times.
//I suspect a temperature related issue, combined with the fbw f1 crystal which is out of specs
//After a initial period on 1500000, revert to 230400
//We still start at 1500000 to remain compatible with original PX4 firmware. (which always runs at 1500000)
uart_periph_set_baudrate(intermcu.device->periph, B230400);
intermcu.stable_px4_baud = CHANGING_BAUD;
px4bl_tid = sys_time_register_timer(1.0, NULL);
return;
}
#ifdef SYS_TIME_LED
LED_ON(SYS_TIME_LED);
#endif
if (b == px4RebootSequence[px4RebootSequenceCount]) {
px4RebootSequenceCount++;
} else {
px4RebootSequenceCount = 0;
}
if (px4RebootSequenceCount >= 6) { // 6 = length of rebootSequence + 1
px4RebootSequenceCount = 0; // should not be necessary...
//send some magic back
//this is the same as the Pixhawk IO code would send
intermcu.device->put_byte(intermcu.device->periph, 0, 0x00);
intermcu.device->put_byte(intermcu.device->periph, 0, 0xe5);
intermcu.device->put_byte(intermcu.device->periph, 0, 0x32);
intermcu.device->put_byte(intermcu.device->periph, 0, 0x0a);
intermcu.device->put_byte(intermcu.device->periph, 0,
0x66); // dummy byte, seems to be necessary otherwise one byte is missing at the fmu side...
while (((struct uart_periph *)(intermcu.device->periph))->tx_running) {
// tx_running is volatile now, so LED_TOGGLE not necessary anymore
#ifdef SYS_TIME_LED
LED_TOGGLE(SYS_TIME_LED);
#endif
}
#ifdef SYS_TIME_LED
LED_OFF(SYS_TIME_LED);
#endif
scb_reset_system();
}
}
}
// Init function
void radio_control_impl_init(void) {
sbus.frame_available = FALSE;
sbus.status = SBUS_STATUS_UNINIT;
// Set UART parameters (100K, 8 bits, 2 stops, even parity)
uart_periph_set_bits_stop_parity(&SBUS_UART_DEV, UBITS_8, USTOP_2, UPARITY_EVEN);
uart_periph_set_baudrate(&SBUS_UART_DEV, B100000);
// Set polarity
#ifdef RC_POLARITY_GPIO_PORT
gpio_setup_output(RC_POLARITY_GPIO_PORT, RC_POLARITY_GPIO_PIN);
RC_SET_POLARITY(RC_POLARITY_GPIO_PORT, RC_POLARITY_GPIO_PIN);
#endif
}
void sbus_common_init(struct Sbus *sbus_p, struct uart_periph *dev)
{
sbus_p->frame_available = false;
sbus_p->status = SBUS_STATUS_UNINIT;
// Set UART parameters (100K, 8 bits, 2 stops, even parity)
uart_periph_set_bits_stop_parity(dev, UBITS_8, USTOP_2, UPARITY_EVEN);
uart_periph_set_baudrate(dev, B100000);
// Set polarity
#ifdef RC_POLARITY_GPIO_PORT
gpio_setup_output(RC_POLARITY_GPIO_PORT, RC_POLARITY_GPIO_PIN);
RC_SET_POLARITY(RC_POLARITY_GPIO_PORT, RC_POLARITY_GPIO_PIN);
#endif
}
void uart4_init( void ) {
uart_periph_init(&uart4);
uart4.reg_addr = (void *)UART4;
/* init RCC and GPIOs */
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART4EN);
set_uart_pin(UART4_GPIO_PORT_RX, UART4_GPIO_RX, UART4_GPIO_AF);
set_uart_pin(UART4_GPIO_PORT_TX, UART4_GPIO_TX, UART4_GPIO_AF);
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_UART4_IRQ);
/* Configure USART */
uart_periph_set_mode(&uart4, USE_UART4_TX, USE_UART4_RX, FALSE);
uart_periph_set_baudrate(&uart4, UART4_BAUD);
}
void uart1_init( void ) {
uart_periph_init(&uart1);
uart1.reg_addr = (void *)USART1;
/* init RCC and GPIOs */
#if defined(STM32F4)
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_USART1EN);
set_uart_pin(UART1_GPIO_PORT_RX, UART1_GPIO_RX, UART1_GPIO_AF);
set_uart_pin(UART1_GPIO_PORT_TX, UART1_GPIO_TX, UART1_GPIO_AF);
#elif defined(STM32F1)
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_USART1EN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN);
gpio_set_mode(GPIO_BANK_USART1_TX, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART1_TX);
gpio_set_mode(GPIO_BANK_USART1_RX, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO_USART1_RX);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART1_IRQ);
#if UART1_HW_FLOW_CONTROL
#warning "USING UART1 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS gpios */
#if defined(STM32F4)
set_uart_pin(UART1_GPIO_PORT_CTS, UART1_GPIO_CTS, UART1_GPIO_AF);
set_uart_pin(UART1_GPIO_PORT_RTS, UART1_GPIO_RTS, UART1_GPIO_AF);
#elif defined(STM32F1)
gpio_set_mode(GPIO_BANK_USART1_RTS, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART1_RTS);
gpio_set_mode(GPIO_BANK_USART1_CTS, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO_USART1_CTS);
#endif
#endif
/* Configure USART1, enable hardware flow control*/
uart_periph_set_mode(&uart1, USE_UART1_TX, USE_UART1_RX, UART1_HW_FLOW_CONTROL);
/* Set USART1 baudrate and enable interrupt */
uart_periph_set_baudrate(&uart1, UART1_BAUD);
}
void sbus_common_init(struct Sbus *sbus_p, struct uart_periph *dev,
gpio_port_t gpio_polarity_port, uint16_t gpio_polarity_pin)
{
sbus_p->frame_available = false;
sbus_p->status = SBUS_STATUS_UNINIT;
// Set UART parameters (100K, 8 bits, 2 stops, even parity)
uart_periph_set_baudrate(dev, B100000);
uart_periph_set_bits_stop_parity(dev, UBITS_8, USTOP_2, UPARITY_EVEN);
// Try to invert RX data logic when available in hardware periph
uart_periph_invert_data_logic(dev, true, false);
// Set polarity (when not done in hardware, don't use both!)
if (gpio_polarity_port != 0) {
gpio_setup_output(gpio_polarity_port, gpio_polarity_pin);
RC_SET_POLARITY(gpio_polarity_port, gpio_polarity_pin);
}
}
// Init function
void radio_control_impl_init(void) {
sbus.frame_available = FALSE;
sbus.status = SBUS_STATUS_UNINIT;
// Set UART parameters (100K, 8 bits, 2 stops, even parity)
uart_periph_set_bits_stop_parity(&SBUS_UART_DEV, UBITS_8, USTOP_2, UPARITY_EVEN);
uart_periph_set_baudrate(&SBUS_UART_DEV, B100000);
// Set polarity
#ifdef RC_POLARITY_GPIO_PORT
gpio_setup_output(RC_POLARITY_GPIO_PORT, RC_POLARITY_GPIO_PIN);
RC_SET_POLARITY(RC_POLARITY_GPIO_PORT, RC_POLARITY_GPIO_PIN);
#endif
// Register telemetry message
#if PERIODIC_TELEMETRY
register_periodic_telemetry(DOWNLINK_TELEMETRY, "PPM", send_sbus);
#endif
}
void uart5_init( void ) {
uart_periph_init(&uart5);
uart5.reg_addr = (void *)UART5;
/* init RCC and GPIOs */
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART5EN);
#if USE_UART5_TX
gpio_setup_pin_af(UART5_GPIO_PORT_TX, UART5_GPIO_TX, UART5_GPIO_AF, TRUE);
#endif
#if USE_UART5_RX
gpio_setup_pin_af(UART5_GPIO_PORT_RX, UART5_GPIO_RX, UART5_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_UART5_IRQ);
/* Configure USART */
uart_periph_set_mode(&uart5, USE_UART5_TX, USE_UART5_RX, FALSE);
uart_periph_set_baudrate(&uart5, UART5_BAUD);
}
void uart3_init( void ) {
uart_periph_init(&uart3);
uart3.reg_addr = (void *)USART3;
/* init RCC */
#if defined(STM32F4)
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART3EN);
set_uart_pin(UART3_GPIO_PORT_RX, UART3_GPIO_RX, UART3_GPIO_AF);
set_uart_pin(UART3_GPIO_PORT_TX, UART3_GPIO_TX, UART3_GPIO_AF);
#elif defined(STM32F1)
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART3EN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN);
AFIO_MAPR |= AFIO_MAPR_USART3_REMAP_PARTIAL_REMAP;
gpio_set_mode(GPIO_BANK_USART3_PR_TX, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART3_PR_TX);
gpio_set_mode(GPIO_BANK_USART3_PR_RX, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO_USART3_PR_RX);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART3_IRQ);
#if UART3_HW_FLOW_CONTROL && defined(STM32F4)
#warning "USING UART3 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS pins */
set_uart_pin(UART3_GPIO_PORT_CTS, UART3_GPIO_CTS, UART3_GPIO_AF);
set_uart_pin(UART3_GPIO_PORT_RTS, UART3_GPIO_RTS, UART3_GPIO_AF);
#endif
/* Configure USART Tx,Rx, and hardware flow control*/
uart_periph_set_mode(&uart3, USE_UART3_TX, USE_UART3_RX, UART3_HW_FLOW_CONTROL);
/* Configure USART */
uart_periph_set_baudrate(&uart3, UART3_BAUD);
}
void uart5_init( void ) {
uart_periph_init(&uart5);
uart5.reg_addr = (void *)UART5;
/* init RCC and GPIOs */
rcc_periph_clock_enable(RCC_UART5);
#if USE_UART5_TX
gpio_setup_pin_af(UART5_GPIO_PORT_TX, UART5_GPIO_TX, UART5_GPIO_AF, TRUE);
#endif
#if USE_UART5_RX
gpio_setup_pin_af(UART5_GPIO_PORT_RX, UART5_GPIO_RX, UART5_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_UART5_IRQ);
/* Configure USART */
uart_periph_set_mode(&uart5, USE_UART5_TX, USE_UART5_RX, FALSE);
uart_periph_set_bits_stop_parity(&uart5, UART5_BITS, UART5_STOP, UART5_PARITY);
uart_periph_set_baudrate(&uart5, UART5_BAUD);
}
void uart1_init(void)
{
uart_periph_init(&uart1);
strncpy(uart1.dev, UART1_DEV, UART_DEV_NAME_SIZE);
uart_periph_set_baudrate(&uart1, UART1_BAUD);
}
void uart2_init(void)
{
uart_periph_init(&uart2);
strncpy(uart2.dev, UART2_DEV, UART_DEV_NAME_SIZE);
uart_periph_set_baudrate(&uart2, UART2_BAUD);
}
void uart3_init(void)
{
uart_periph_init(&uart3);
strncpy(uart3.dev, UART3_DEV, UART_DEV_NAME_SIZE);
uart_periph_set_baudrate(&uart3, UART3_BAUD);
}
void uart4_init(void)
{
uart_periph_init(&uart4);
strncpy(uart4.dev, UART4_DEV, UART_DEV_NAME_SIZE);
uart_periph_set_baudrate(&uart4, UART4_BAUD);
}
void uart1_init( void ) {
uart_periph_init(&uart1);
uart.dev = UART1_DEV;
uart_periph_set_baudrate(&uart1,UART1_BAUD,FALSE);
}
void uart0_init( void ) {
uart_periph_init(&uart0);
uart.dev = UART0_DEV;
uart_periph_set_baudrate(&uart0,UART0_BAUD,FALSE);
}
void uart5_init(void)
{
uart_periph_init(&uart5);
strncpy(uart5.dev, UART5_DEV, UART_DEV_NAME_SIZE);
uart_periph_set_baudrate(&uart5, UART5_BAUD);
}
void uart6_init(void)
{
uart_periph_init(&uart6);
strncpy(uart6.dev, UART6_DEV, UART_DEV_NAME_SIZE);
uart_periph_set_baudrate(&uart6, UART6_BAUD);
}
void px4flash_event(void)
{
if (PX4IO_PORT->char_available(PX4IO_PORT->periph)) {
if (!setToBootloaderMode) {
//ignore anything coming from IO if not in bootloader mode (which should be nothing)
} else {
//relay everything from IO to the laptop
while (PX4IO_PORT->char_available(PX4IO_PORT->periph)) {
unsigned char b = PX4IO_PORT->get_byte(PX4IO_PORT->periph);
FLASH_PORT->put_byte(FLASH_PORT->periph, b);
}
}
}
//TODO: check if bootloader timeout was surpassed
if (FLASH_PORT->char_available(FLASH_PORT->periph) && !setToBootloaderMode) {
// TMP TEST
// while (FLASH_PORT->char_available(FLASH_PORT->periph)) {
// unsigned char bla = FLASH_PORT->get_byte(FLASH_PORT->periph);
// FLASH_PORT->put_byte(FLASH_PORT->periph,bla);
// }
// return;
//check whether this is flash related communication, and for who (ap/fbw)
int state = 0;
while (state < 4 && FLASH_PORT->char_available(FLASH_PORT->periph)) {
unsigned char b = FLASH_PORT->get_byte(FLASH_PORT->periph);
switch (state) {
case (0) :
if (b == 'p') { state++; } else { return; }
break;
case (1) :
if (b == 'p') { state++; } else { return; }
break;
case (2) :
if (b == 'r') { state++; } else { return; }
break;
case (3) :
if (b == 'z') { state++; } else { return; }
break;
default :
break;
}
}
if (state != 4) {return;}
//TODO: check if/how this interferes with flashing original PX4 firmware
unsigned char target = FLASH_PORT->get_byte(FLASH_PORT->periph);
if (target == '1') { //target ap
//the target is the ap, so reboot to PX4 bootloader
scb_reset_system();
} else { // target fbw
//the target is the fbw, so reboot the fbw and switch to relay mode
//first check if the bootloader has not timeout:
if (sys_time_check_and_ack_timer(px4iobl_tid) || px4ioRebootTimeout) {
px4ioRebootTimeout = TRUE;
sys_time_cancel_timer(px4iobl_tid);
FLASH_PORT->put_byte(FLASH_PORT->periph, 'T');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'I');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'M');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'E');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'O');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'U');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'T'); // use 7 chars as answer
return;
} { // FBW OK OK hollay hollay :)
FLASH_PORT->put_byte(FLASH_PORT->periph, 'F');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'B');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'W');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'O');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'K');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'O');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'K'); // use 7 chars as answer
}
//stop all intermcu communication:
disable_inter_comm(true);
/*
* The progdieshit define is very usefull, if for whatever reason the (normal, not bootloader) firmware on the IO chip became disfunct.
* In that case:
* 1. enable this define
* 2. build and upload the fmu f4 chip (ap target in pprz center)
* 3. build the io code, and convert the firmware using the following command:
* /home/houjebek/paparazzi/sw/tools/px4/px_mkfw.py --prototype "/home/houjebek/px4/Firmware/Images/px4io-v2.prototype" --image /home/houjebek/paparazzi/var/aircrafts/Iris/fbw/fbw.bin > /home/houjebek/paparazzi/var/aircrafts/Iris/fbw/fbw.px4
* 4. Start the following command:
* /home/houjebek/paparazzi/sw/tools/px4/px_uploader.py --port "/dev/ttyACM0" /home/houjebek/paparazzi/var/aircrafts/Iris/fbw/fbw.px4
* 5a. Either, boot the Pixhawk (reconnect usb) holding the IO reset button until the FMU led stops blinking fast (i.e. exits its own bootloader)
* 5b Or, press the IO reset button on the pixhawk
* 6. Watch the output of the command of step 4, it should recognize the IO bootloader and start flashing. If not try repeating step 5a.
* 7. Don forget to disable the define and upload the ap again :)
*/
// #define progdieshit
#ifndef progdieshit
//send the reboot to bootloader command:
static struct IOPacket dma_packet;
dma_packet.count_code = 0x40 + 0x01;
dma_packet.crc = 0;
dma_packet.page = PX4IO_PAGE_SETUP;
dma_packet.offset = PX4IO_P_SETUP_REBOOT_BL;
dma_packet.regs[0] = PX4IO_REBOOT_BL_MAGIC;
dma_packet.crc = crc_packet(&dma_packet);
struct IOPacket *pkt = &dma_packet;
uint8_t *p = (uint8_t *)pkt;
PX4IO_PORT->put_byte(PX4IO_PORT->periph, p[0]);
PX4IO_PORT->put_byte(PX4IO_PORT->periph, p[1]);
PX4IO_PORT->put_byte(PX4IO_PORT->periph, p[2]);
PX4IO_PORT->put_byte(PX4IO_PORT->periph, p[3]);
PX4IO_PORT->put_byte(PX4IO_PORT->periph, p[4]);
PX4IO_PORT->put_byte(PX4IO_PORT->periph, p[5]);
sys_time_usleep(5000); // this seems to be close to the minimum delay necessary to process this packet at the IO side
//the pixhawk IO chip should respond with:
// 0x00 ( PKT_CODE_SUCCESS )
// 0xe5
// 0x32
// 0x0a
//After that, the IO chips reboots into bootloader mode, in which it will stay for a short period
//The baudrate in bootloader mode ic changed to 115200 (normal operating baud is 1500000, at least for original pixhawk fmu firmware)
//state machine
state = 0;
while (state < 4 && PX4IO_PORT->char_available(PX4IO_PORT->periph)) {
unsigned char b = PX4IO_PORT->get_byte(PX4IO_PORT->periph);
switch (state) {
case (0) :
if (b == PKT_CODE_SUCCESS) { state++; } else { state = 0; }
break;
case (1) :
if (b == 0xe5) { state++; } else { state = 0; }
break;
case (2) :
if (b == 0x32) { state++; } else { state = 0; }
break;
case (3) :
if (b == 0x0a) { state++; } else { state = 0; }
break;
default :
break;
}
}
#else
int state = 4;
#endif
if (state == 4) {
uart_periph_set_baudrate(PX4IO_PORT->periph, B115200);
/* look for the bootloader for 150 ms */
int ret = 0;
for (int i = 0; i < 15 && !ret ; i++) {
sys_time_usleep(10000);
//send a get_sync command in order to keep the io in bootloader mode
PX4IO_PORT->put_byte(PX4IO_PORT->periph, PROTO_GET_SYNC);
PX4IO_PORT->put_byte(PX4IO_PORT->periph, PROTO_EOC);
//get_sync should be replied with, so check if that happens and
//all other bytes are discarded, hopefully those were not important
//(they may be caused by sending multiple syncs)
while (PX4IO_PORT->char_available(PX4IO_PORT->periph)) {
unsigned char b = PX4IO_PORT->get_byte(PX4IO_PORT->periph);
if (b == PROTO_INSYNC) {
setToBootloaderMode = true;
ret = 1;
break;
}
}
}
if (setToBootloaderMode) {
//if successfully entered bootloader mode, clear any remaining bytes (which may have a function, but I did not check)
while (PX4IO_PORT->char_available(PX4IO_PORT->periph)) {PX4IO_PORT->get_byte(PX4IO_PORT->periph);}
}
} else {
FLASH_PORT->put_byte(FLASH_PORT->periph, 'E'); //TODO: find out what the PX4 protocol for error feedback is...
FLASH_PORT->put_byte(FLASH_PORT->periph, 'R');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'R');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'O');
FLASH_PORT->put_byte(FLASH_PORT->periph, 'R');
FLASH_PORT->put_byte(FLASH_PORT->periph, '!');
FLASH_PORT->put_byte(FLASH_PORT->periph, ' '); // use 7 chars as answer
}
}
} else if (FLASH_PORT->char_available(FLASH_PORT->periph)) {
//already in bootloader mode, just directly relay data
while (FLASH_PORT->char_available(FLASH_PORT->periph)) {
unsigned char b = FLASH_PORT->get_byte(FLASH_PORT->periph);
PX4IO_PORT->put_byte(PX4IO_PORT->periph, b);
}
}
}
void uart0_init(void)
{
uart_periph_init(&uart0);
strncpy(uart0.dev, UART0_DEV, UART_DEV_NAME_SIZE);
uart_periph_set_baudrate(&uart0, UART0_BAUD);
}
