diff --git a/flight/AHRS/pios_board.c b/flight/AHRS/pios_board.c index 395eadd39..15c5999c0 100644 --- a/flight/AHRS/pios_board.c +++ b/flight/AHRS/pios_board.c @@ -54,7 +54,7 @@ static const struct pios_spi_cfg pios_spi_op_cfg = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_op_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC4 | DMA1_FLAG_TE4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4), @@ -153,11 +153,11 @@ void PIOS_SPI_op_irq_handler(void) extern void PIOS_ADC_handler(void); void DMA1_Channel1_IRQHandler() __attribute__ ((alias("PIOS_ADC_handler"))); // Remap the ADC DMA handler to this one -const struct pios_adc_cfg pios_adc_cfg = { +static const struct pios_adc_cfg pios_adc_cfg = { .dma = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_ADC_DMA_Handler, + .handler = NULL, .flags = (DMA1_FLAG_TC1 | DMA1_FLAG_TE1 | DMA1_FLAG_HT1 | DMA1_FLAG_GL1), .init = { .NVIC_IRQChannel = DMA1_Channel1_IRQn, @@ -205,10 +205,7 @@ void PIOS_ADC_handler() { /* * AUX USART */ -void PIOS_USART_aux_irq_handler(void); -void USART3_IRQHandler() - __attribute__ ((alias("PIOS_USART_aux_irq_handler"))); -const struct pios_usart_cfg pios_usart_aux_cfg = { +static const struct pios_usart_cfg pios_usart_aux_cfg = { .regs = USART3, .init = { #if defined (PIOS_USART_BAUDRATE) @@ -224,7 +221,7 @@ const struct pios_usart_cfg pios_usart_aux_cfg = { .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_aux_irq_handler, + .handler = NULL, .init = { .NVIC_IRQChannel = USART3_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, @@ -250,12 +247,6 @@ const struct pios_usart_cfg pios_usart_aux_cfg = { }, }; -static uint32_t pios_usart_aux_id; -void PIOS_USART_aux_irq_handler(void) -{ - PIOS_USART_IRQ_Handler(pios_usart_aux_id); -} - #endif /* PIOS_INCLUDE_USART */ #if defined(PIOS_INCLUDE_COM) @@ -279,7 +270,7 @@ void I2C1_EV_IRQHandler() void I2C1_ER_IRQHandler() __attribute__ ((alias("PIOS_I2C_main_adapter_er_irq_handler"))); -const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { +static const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { .regs = I2C1, .init = { .I2C_Mode = I2C_Mode_I2C, @@ -307,7 +298,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { }, }, .event = { - .handler = PIOS_I2C_main_adapter_ev_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C1_EV_IRQn, @@ -317,7 +308,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { }, }, .error = { - .handler = PIOS_I2C_main_adapter_er_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C1_ER_IRQn, @@ -388,6 +379,7 @@ void PIOS_Board_Init(void) { /* Communication system */ #if !defined(PIOS_ENABLE_DEBUG_PINS) #if defined(PIOS_INCLUDE_COM) + uint32_t pios_usart_aux_id; if (PIOS_USART_Init(&pios_usart_aux_id, &pios_usart_aux_cfg)) { PIOS_DEBUG_Assert(0); } diff --git a/flight/Bootloaders/AHRS/pios_board.c b/flight/Bootloaders/AHRS/pios_board.c index 2d3c33a8c..fc3774214 100644 --- a/flight/Bootloaders/AHRS/pios_board.c +++ b/flight/Bootloaders/AHRS/pios_board.c @@ -55,7 +55,7 @@ static const struct pios_spi_cfg .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_op_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC4 | DMA1_FLAG_TE4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4), .init = { .NVIC_IRQChannel = DMA1_Channel4_IRQn, diff --git a/flight/Bootloaders/OpenPilot/pios_board.c b/flight/Bootloaders/OpenPilot/pios_board.c index 0f8e4ae81..d1727f6f6 100644 --- a/flight/Bootloaders/OpenPilot/pios_board.c +++ b/flight/Bootloaders/OpenPilot/pios_board.c @@ -60,7 +60,7 @@ const struct pios_spi_cfg .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_ahrs_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC4 | DMA1_FLAG_TE4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4), .init = { .NVIC_IRQChannel = DMA1_Channel4_IRQn, @@ -143,9 +143,9 @@ void PIOS_SPI_ahrs_irq_handler(void) { /* * Telemetry USART */ -void PIOS_USART_telem_irq_handler(void); -void USART2_IRQHandler() __attribute__ ((alias ("PIOS_USART_telem_irq_handler"))); -const struct pios_usart_cfg pios_usart_telem_cfg = { .regs = USART2, .init = { +const struct pios_usart_cfg pios_usart_telem_cfg = { + .regs = USART2, + .init = { #if defined (PIOS_COM_TELEM_BAUDRATE) .USART_BaudRate = PIOS_COM_TELEM_BAUDRATE, #else @@ -157,7 +157,7 @@ const struct pios_usart_cfg pios_usart_telem_cfg = { .regs = USART2, .init = { .USART_HardwareFlowControl = USART_HardwareFlowControl_None, .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_telem_irq_handler, + .handler = NULL, .init = { .NVIC_IRQChannel = USART2_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, @@ -180,11 +180,6 @@ const struct pios_usart_cfg pios_usart_telem_cfg = { .regs = USART2, .init = { }, }, }; -static uint32_t pios_usart_telem_rf_id; -void PIOS_USART_telem_irq_handler(void) { - PIOS_USART_IRQ_Handler(pios_usart_telem_rf_id); -} - #endif /* PIOS_INCLUDE_USART */ #if defined(PIOS_INCLUDE_COM) @@ -218,6 +213,7 @@ void PIOS_Board_Init(void) { /* Initialize the PiOS library */ #if defined(PIOS_INCLUDE_COM) + uint32_t pios_usart_telem_rf_id; if (PIOS_USART_Init(&pios_usart_telem_rf_id, &pios_usart_telem_cfg)) { PIOS_DEBUG_Assert(0); } diff --git a/flight/CopterControl/Makefile b/flight/CopterControl/Makefile index a83ec4122..91c78ccc6 100644 --- a/flight/CopterControl/Makefile +++ b/flight/CopterControl/Makefile @@ -45,10 +45,7 @@ ENABLE_DEBUG_PINS ?= NO # Set to Yes to enable the AUX UART which is mapped on the S1 (Tx) and S2 (Rx) servo outputs ENABLE_AUX_UART ?= NO -USE_TELEMETRY ?= YES USE_GPS ?= NO -USE_SPEKTRUM ?= NO -USE_SBUS ?= NO USE_I2C ?= NO @@ -169,6 +166,7 @@ SRC += $(OPUAVSYNTHDIR)/mixersettings.c SRC += $(OPUAVSYNTHDIR)/mixerstatus.c SRC += $(OPUAVSYNTHDIR)/firmwareiapobj.c SRC += $(OPUAVSYNTHDIR)/attitudesettings.c +SRC += $(OPUAVSYNTHDIR)/hwsettings.c #${wildcard ${OBJ}/$(shell echo $(VAR) | tr A-Z a-z)/*.c} #SRC += ${foreach OBJ, ${UAVOBJECTS}, $(UAVOBJECTS)/$(OBJ).c} # Cant use until i can automatically generate list of UAVObjects @@ -388,32 +386,8 @@ endif # USART port functions. NO means do not use this function. # YES means use with default USART port number (hardware-dependent). # Number means use with specified USART port number (this value). -ifneq ($(USE_TELEMETRY), NO) -CDEFS += -DUSE_TELEMETRY -ifneq ($(USE_TELEMETRY), YES) -CDEFS += -DPIOS_PORT_TELEMETRY=$(USE_TELEMETRY) -endif -endif - ifneq ($(USE_GPS), NO) CDEFS += -DUSE_GPS -ifneq ($(USE_GPS), YES) -CDEFS += -DPIOS_PORT_GPS=$(USE_GPS) -endif -endif - -ifneq ($(USE_SPEKTRUM), NO) -CDEFS += -DUSE_SPEKTRUM -ifneq ($(USE_SPEKTRUM), YES) -CDEFS += -DPIOS_PORT_SPEKTRUM=$(USE_SPEKTRUM) -endif -endif - -ifneq ($(USE_SBUS), NO) -CDEFS += -DUSE_SBUS -ifneq ($(USE_SBUS), YES) -CDEFS += -DPIOS_PORT_SBUS=$(USE_SBUS) -endif endif ifeq ($(USE_I2C), YES) diff --git a/flight/CopterControl/System/inc/pios_config.h b/flight/CopterControl/System/inc/pios_config.h index 0f243b7cf..d5805062d 100644 --- a/flight/CopterControl/System/inc/pios_config.h +++ b/flight/CopterControl/System/inc/pios_config.h @@ -45,25 +45,15 @@ #define PIOS_INCLUDE_RCVR -/* Receiver interfaces - only one allowed */ -#if !defined(USE_SPEKTRUM) && !defined(USE_SBUS) +/* Supported receiver interfaces */ +#define PIOS_INCLUDE_SPEKTRUM +#define PIOS_INCLUDE_SBUS //#define PIOS_INCLUDE_PPM #define PIOS_INCLUDE_PWM -#endif -/* USART-based PIOS modules */ -#if defined(USE_TELEMETRY) +/* Supported USART-based PIOS modules */ #define PIOS_INCLUDE_TELEMETRY_RF -#endif -#if defined(USE_GPS) -#define PIOS_INCLUDE_GPS -#endif -#if defined(USE_SPEKTRUM) -#define PIOS_INCLUDE_SPEKTRUM -#endif -#if defined(USE_SBUS) -#define PIOS_INCLUDE_SBUS -#endif +//#define PIOS_INCLUDE_GPS #define PIOS_INCLUDE_SERVO #define PIOS_INCLUDE_SPI @@ -97,8 +87,8 @@ /* Alarm Thresholds */ #define HEAP_LIMIT_WARNING 220 -#define HEAP_LIMIT_CRITICAL 150 -#define CPULOAD_LIMIT_WARNING 80 +#define HEAP_LIMIT_CRITICAL 40 +#define CPULOAD_LIMIT_WARNING 85 #define CPULOAD_LIMIT_CRITICAL 95 /* Task stack sizes */ diff --git a/flight/CopterControl/System/pios_board.c b/flight/CopterControl/System/pios_board.c index c88c1fc9f..3db2fda47 100644 --- a/flight/CopterControl/System/pios_board.c +++ b/flight/CopterControl/System/pios_board.c @@ -30,6 +30,8 @@ #include #include #include +#include +#include #if defined(PIOS_INCLUDE_SPI) @@ -43,7 +45,7 @@ void PIOS_SPI_flash_accel_irq_handler(void); void DMA1_Channel4_IRQHandler() __attribute__ ((alias ("PIOS_SPI_flash_accel_irq_handler"))); void DMA1_Channel5_IRQHandler() __attribute__ ((alias ("PIOS_SPI_flash_accel_irq_handler"))); -const struct pios_spi_cfg pios_spi_flash_accel_cfg = { +static const struct pios_spi_cfg pios_spi_flash_accel_cfg = { .regs = SPI2, .init = { .SPI_Mode = SPI_Mode_Master, @@ -61,7 +63,7 @@ const struct pios_spi_cfg pios_spi_flash_accel_cfg = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_flash_accel_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC4 | DMA1_FLAG_TE4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4), .init = { .NVIC_IRQChannel = DMA1_Channel4_IRQn, @@ -150,11 +152,11 @@ void PIOS_SPI_flash_accel_irq_handler(void) extern void PIOS_ADC_handler(void); void DMA1_Channel1_IRQHandler() __attribute__ ((alias("PIOS_ADC_handler"))); // Remap the ADC DMA handler to this one -const struct pios_adc_cfg pios_adc_cfg = { +static const struct pios_adc_cfg pios_adc_cfg = { .dma = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_ADC_DMA_Handler, + .handler = NULL, .flags = (DMA1_FLAG_TC1 | DMA1_FLAG_TE1 | DMA1_FLAG_HT1 | DMA1_FLAG_GL1), .init = { .NVIC_IRQChannel = DMA1_Channel1_IRQn, @@ -199,141 +201,12 @@ void PIOS_ADC_handler() { #include "pios_usart_priv.h" -/* - * Serial port configuration. - * TODO: This should be dynamic in the future. - * But for now define any compatile combination of: - * USE_I2C (shared with USART3) - * USE_TELEMETRY - * USE_GPS - * USE_SPEKTRUM - * USE_SBUS (USART1 only, it needs an invertor) - * and optionally define PIOS_PORT_* to USART port numbers - */ - -/* Serial telemetry: USART1 or USART3 */ -#if !defined(PIOS_PORT_TELEMETRY) -#define PIOS_PORT_TELEMETRY 1 -#endif - -/* GPS receiver: USART1 or USART3 */ -#if !defined(PIOS_PORT_GPS) -#define PIOS_PORT_GPS 3 -#endif - -/* Spektrum satellite receiver: USART1 or USART3 */ -#if !defined(PIOS_PORT_SPEKTRUM) -#define PIOS_PORT_SPEKTRUM 3 -#endif - -/* Futaba S.Bus receiver: USART1 only (needs invertor) */ -#if !defined(PIOS_PORT_SBUS) -#define PIOS_PORT_SBUS 1 -#endif - -/* - * Define USART port configurations and check for conflicts - * making sure they do not conflict with each other and with I2C. - */ -#define USART_GPIO(port) (((port) == 1) ? GPIOA : GPIOB) -#define USART_RXIO(port) (((port) == 1) ? GPIO_Pin_10 : GPIO_Pin_11) -#define USART_TXIO(port) (((port) == 1) ? GPIO_Pin_9 : GPIO_Pin_10) - -#if defined(USE_TELEMETRY) -#if defined(USE_I2C) && (PIOS_PORT_TELEMETRY == 3) -#error defined(USE_I2C) && (PIOS_PORT_TELEMETRY == 3) -#endif -#if (PIOS_PORT_TELEMETRY == 1) -#define PIOS_USART_TELEMETRY USART1 -#define PIOS_IRQH_TELEMETRY USART1_IRQHandler -#define PIOS_IRQC_TELEMETRY USART1_IRQn -#else -#define PIOS_USART_TELEMETRY USART3 -#define PIOS_IRQH_TELEMETRY USART3_IRQHandler -#define PIOS_IRQC_TELEMETRY USART3_IRQn -#endif -#define PIOS_GPIO_TELEMETRY USART_GPIO(PIOS_PORT_TELEMETRY) -#define PIOS_RXIO_TELEMETRY USART_RXIO(PIOS_PORT_TELEMETRY) -#define PIOS_TXIO_TELEMETRY USART_TXIO(PIOS_PORT_TELEMETRY) -#endif - -#if defined(USE_GPS) -#if defined(USE_I2C) && (PIOS_PORT_GPS == 3) -#error defined(USE_I2C) && (PIOS_PORT_GPS == 3) -#endif -#if defined(USE_TELEMETRY) && (PIOS_PORT_TELEMETRY == PIOS_PORT_GPS) -#error defined(USE_TELEMETRY) && (PIOS_PORT_TELEMETRY == PIOS_PORT_GPS) -#endif -#if (PIOS_PORT_GPS == 1) -#define PIOS_USART_GPS USART1 -#define PIOS_IRQH_GPS USART1_IRQHandler -#define PIOS_IRQC_GPS USART1_IRQn -#else -#define PIOS_USART_GPS USART3 -#define PIOS_IRQH_GPS USART3_IRQHandler -#define PIOS_IRQC_GPS USART3_IRQn -#endif -#define PIOS_GPIO_GPS USART_GPIO(PIOS_PORT_GPS) -#define PIOS_RXIO_GPS USART_RXIO(PIOS_PORT_GPS) -#define PIOS_TXIO_GPS USART_TXIO(PIOS_PORT_GPS) -#endif - -#if defined(USE_SPEKTRUM) -#if defined(USE_I2C) && (PIOS_PORT_SPEKTRUM == 3) -#error defined(USE_I2C) && (PIOS_PORT_SPEKTRUM == 3) -#endif -#if defined(USE_TELEMETRY) && (PIOS_PORT_SPEKTRUM == PIOS_PORT_TELEMETRY) -#error defined(USE_TELEMETRY) && (PIOS_PORT_SPEKTRUM == PIOS_PORT_TELEMETRY) -#endif -#if defined(USE_GPS) && (PIOS_PORT_SPEKTRUM == PIOS_PORT_GPS) -#error defined(USE_GPS) && (PIOS_PORT_SPEKTRUM == PIOS_PORT_GPS) -#endif -#if defined(USE_SBUS) -#error defined(USE_SPEKTRUM) && defined(USE_SBUS) -#endif -#if (PIOS_PORT_SPEKTRUM == 1) -#define PIOS_USART_SPEKTRUM USART1 -#define PIOS_IRQH_SPEKTRUM USART1_IRQHandler -#define PIOS_IRQC_SPEKTRUM USART1_IRQn -#else -#define PIOS_USART_SPEKTRUM USART3 -#define PIOS_IRQH_SPEKTRUM USART3_IRQHandler -#define PIOS_IRQC_SPEKTRUM USART3_IRQn -#endif -#define PIOS_GPIO_SPEKTRUM USART_GPIO(PIOS_PORT_SPEKTRUM) -#define PIOS_RXIO_SPEKTRUM USART_RXIO(PIOS_PORT_SPEKTRUM) -#define PIOS_TXIO_SPEKTRUM USART_TXIO(PIOS_PORT_SPEKTRUM) -#endif - -#if defined(USE_SBUS) -#if (PIOS_PORT_SBUS != 1) -#error (PIOS_PORT_SBUS != 1) -#endif -#if defined(USE_TELEMETRY) && (PIOS_PORT_SBUS == PIOS_PORT_TELEMETRY) -#error defined(USE_TELEMETRY) && (PIOS_PORT_SBUS == PIOS_PORT_TELEMETRY) -#endif -#if defined(USE_GPS) && (PIOS_PORT_SBUS == PIOS_PORT_GPS) -#error defined(USE_GPS) && (PIOS_PORT_SBUS == PIOS_PORT_GPS) -#endif -#if defined(USE_SPEKTRUM) -#error defined(USE_SPEKTRUM) && defined(USE_SBUS) -#endif -#define PIOS_USART_SBUS USART1 -#define PIOS_IRQH_SBUS USART1_IRQHandler -#define PIOS_IRQC_SBUS USART1_IRQn -#define PIOS_GPIO_SBUS USART_GPIO(PIOS_PORT_SBUS) -#define PIOS_RXIO_SBUS USART_RXIO(PIOS_PORT_SBUS) -#define PIOS_TXIO_SBUS USART_TXIO(PIOS_PORT_SBUS) -#endif - #if defined(PIOS_INCLUDE_TELEMETRY_RF) /* * Telemetry USART */ -void PIOS_USART_telem_irq_handler(void); -void PIOS_IRQH_TELEMETRY() __attribute__ ((alias ("PIOS_USART_telem_irq_handler"))); -const struct pios_usart_cfg pios_usart_telem_cfg = { - .regs = PIOS_USART_TELEMETRY, +static const struct pios_usart_cfg pios_usart_telem_main_cfg = { + .regs = USART1, .init = { #if defined (PIOS_COM_TELEM_BAUDRATE) .USART_BaudRate = PIOS_COM_TELEM_BAUDRATE, @@ -347,26 +220,67 @@ const struct pios_usart_cfg pios_usart_telem_cfg = { .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_telem_irq_handler, + .handler = NULL, .init = { - .NVIC_IRQChannel = PIOS_IRQC_TELEMETRY, + .NVIC_IRQChannel = USART1_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, .NVIC_IRQChannelSubPriority = 0, .NVIC_IRQChannelCmd = ENABLE, }, }, .rx = { - .gpio = PIOS_GPIO_TELEMETRY, + .gpio = GPIOA, .init = { - .GPIO_Pin = PIOS_RXIO_TELEMETRY, + .GPIO_Pin = GPIO_Pin_10, .GPIO_Speed = GPIO_Speed_2MHz, .GPIO_Mode = GPIO_Mode_IPU, }, }, .tx = { - .gpio = PIOS_GPIO_TELEMETRY, + .gpio = GPIOA, .init = { - .GPIO_Pin = PIOS_TXIO_TELEMETRY, + .GPIO_Pin = GPIO_Pin_9, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_AF_PP, + }, + }, +}; + +static const struct pios_usart_cfg pios_usart_telem_flexi_cfg = { + .regs = USART3, + .init = { + #if defined (PIOS_COM_TELEM_BAUDRATE) + .USART_BaudRate = PIOS_COM_TELEM_BAUDRATE, + #else + .USART_BaudRate = 57600, + #endif + .USART_WordLength = USART_WordLength_8b, + .USART_Parity = USART_Parity_No, + .USART_StopBits = USART_StopBits_1, + .USART_HardwareFlowControl = USART_HardwareFlowControl_None, + .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, + }, + .irq = { + .handler = NULL, + .init = { + .NVIC_IRQChannel = USART3_IRQn, + .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, + .NVIC_IRQChannelSubPriority = 0, + .NVIC_IRQChannelCmd = ENABLE, + }, + }, + .rx = { + .gpio = GPIOB, + .init = { + .GPIO_Pin = GPIO_Pin_11, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_IPU, + }, + }, + .tx = { + .gpio = GPIOB, + .init = { + .GPIO_Pin = GPIO_Pin_10, .GPIO_Speed = GPIO_Speed_2MHz, .GPIO_Mode = GPIO_Mode_AF_PP, }, @@ -378,10 +292,8 @@ const struct pios_usart_cfg pios_usart_telem_cfg = { /* * GPS USART */ -void PIOS_USART_gps_irq_handler(void); -void PIOS_IRQH_GPS() __attribute__ ((alias ("PIOS_USART_gps_irq_handler"))); -const struct pios_usart_cfg pios_usart_gps_cfg = { - .regs = PIOS_USART_GPS, +static const struct pios_usart_cfg pios_usart_gps_main_cfg = { + .regs = USART1, .init = { #if defined (PIOS_COM_GPS_BAUDRATE) .USART_BaudRate = PIOS_COM_GPS_BAUDRATE, @@ -395,32 +307,259 @@ const struct pios_usart_cfg pios_usart_gps_cfg = { .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_gps_irq_handler, + .handler = NULL, .init = { - .NVIC_IRQChannel = PIOS_IRQC_GPS, + .NVIC_IRQChannel = USART1_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, .NVIC_IRQChannelSubPriority = 0, .NVIC_IRQChannelCmd = ENABLE, }, }, .rx = { - .gpio = PIOS_GPIO_GPS, + .gpio = GPIOA, .init = { - .GPIO_Pin = PIOS_RXIO_GPS, + .GPIO_Pin = GPIO_Pin_10, .GPIO_Speed = GPIO_Speed_2MHz, .GPIO_Mode = GPIO_Mode_IPU, }, }, .tx = { - .gpio = PIOS_GPIO_GPS, + .gpio = GPIOA, .init = { - .GPIO_Pin = PIOS_TXIO_GPS, + .GPIO_Pin = GPIO_Pin_9, .GPIO_Speed = GPIO_Speed_2MHz, .GPIO_Mode = GPIO_Mode_AF_PP, }, }, }; -#endif + +static const struct pios_usart_cfg pios_usart_gps_flexi_cfg = { + .regs = USART3, + .init = { + #if defined (PIOS_COM_GPS_BAUDRATE) + .USART_BaudRate = PIOS_COM_GPS_BAUDRATE, + #else + .USART_BaudRate = 57600, + #endif + .USART_WordLength = USART_WordLength_8b, + .USART_Parity = USART_Parity_No, + .USART_StopBits = USART_StopBits_1, + .USART_HardwareFlowControl = USART_HardwareFlowControl_None, + .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, + }, + .irq = { + .handler = NULL, + .init = { + .NVIC_IRQChannel = USART3_IRQn, + .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, + .NVIC_IRQChannelSubPriority = 0, + .NVIC_IRQChannelCmd = ENABLE, + }, + }, + .rx = { + .gpio = GPIOB, + .init = { + .GPIO_Pin = GPIO_Pin_11, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_IPU, + }, + }, + .tx = { + .gpio = GPIOB, + .init = { + .GPIO_Pin = GPIO_Pin_10, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_AF_PP, + }, + }, +}; +#endif /* PIOS_INCLUDE_GPS */ + +#if defined(PIOS_INCLUDE_SPEKTRUM) +/* + * SPEKTRUM USART + */ +#include + +static const struct pios_usart_cfg pios_usart_spektrum_main_cfg = { + .regs = USART1, + .init = { + #if defined (PIOS_COM_SPEKTRUM_BAUDRATE) + .USART_BaudRate = PIOS_COM_SPEKTRUM_BAUDRATE, + #else + .USART_BaudRate = 115200, + #endif + .USART_WordLength = USART_WordLength_8b, + .USART_Parity = USART_Parity_No, + .USART_StopBits = USART_StopBits_1, + .USART_HardwareFlowControl = USART_HardwareFlowControl_None, + .USART_Mode = USART_Mode_Rx, + }, + .irq = { + .handler = PIOS_SPEKTRUM_irq_handler, + .init = { + .NVIC_IRQChannel = USART1_IRQn, + .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, + .NVIC_IRQChannelSubPriority = 0, + .NVIC_IRQChannelCmd = ENABLE, + }, + }, + .rx = { + .gpio = GPIOA, + .init = { + .GPIO_Pin = GPIO_Pin_10, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_IPU, + }, + }, + .tx = { + .gpio = GPIOA, + .init = { + .GPIO_Pin = GPIO_Pin_9, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_IN_FLOATING, + }, + }, +}; + +static const struct pios_spektrum_cfg pios_spektrum_main_cfg = { + .bind = { + .gpio = GPIOA, + .init = { + .GPIO_Pin = GPIO_Pin_10, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_Out_PP, + }, + }, + .remap = 0, +}; + +static const struct pios_usart_cfg pios_usart_spektrum_flexi_cfg = { + .regs = USART3, + .init = { + #if defined (PIOS_COM_SPEKTRUM_BAUDRATE) + .USART_BaudRate = PIOS_COM_SPEKTRUM_BAUDRATE, + #else + .USART_BaudRate = 115200, + #endif + .USART_WordLength = USART_WordLength_8b, + .USART_Parity = USART_Parity_No, + .USART_StopBits = USART_StopBits_1, + .USART_HardwareFlowControl = USART_HardwareFlowControl_None, + .USART_Mode = USART_Mode_Rx, + }, + .irq = { + .handler = PIOS_SPEKTRUM_irq_handler, + .init = { + .NVIC_IRQChannel = USART3_IRQn, + .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, + .NVIC_IRQChannelSubPriority = 0, + .NVIC_IRQChannelCmd = ENABLE, + }, + }, + .rx = { + .gpio = GPIOA, + .init = { + .GPIO_Pin = GPIO_Pin_11, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_IPU, + }, + }, + .tx = { + .gpio = GPIOA, + .init = { + .GPIO_Pin = GPIO_Pin_10, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_IN_FLOATING, + }, + }, +}; + +static const struct pios_spektrum_cfg pios_spektrum_flexi_cfg = { + .bind = { + .gpio = GPIOB, + .init = { + .GPIO_Pin = GPIO_Pin_11, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_Out_PP, + }, + }, + .remap = 0, +}; + +#endif /* PIOS_INCLUDE_SPEKTRUM */ + +#if defined(PIOS_INCLUDE_SBUS) +/* + * SBUS USART + */ +#include + +static const struct pios_usart_cfg pios_usart_sbus_main_cfg = { + .regs = USART1, + .init = { + #if defined (PIOS_COM_SBUS_BAUDRATE) + .USART_BaudRate = PIOS_COM_SBUS_BAUDRATE, + #else + .USART_BaudRate = 100000, + #endif + .USART_WordLength = USART_WordLength_8b, + .USART_Parity = USART_Parity_Even, + .USART_StopBits = USART_StopBits_2, + .USART_HardwareFlowControl = USART_HardwareFlowControl_None, + .USART_Mode = USART_Mode_Rx, + }, + .irq = { + .handler = PIOS_SBUS_irq_handler, + .init = { + .NVIC_IRQChannel = USART1_IRQn, + .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, + .NVIC_IRQChannelSubPriority = 0, + .NVIC_IRQChannelCmd = ENABLE, + }, + }, + .rx = { + .gpio = GPIOA, + .init = { + .GPIO_Pin = GPIO_Pin_10, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_IPU, + }, + }, + .tx = { + .gpio = GPIOA, + .init = { + .GPIO_Pin = GPIO_Pin_9, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_IN_FLOATING, + }, + }, +}; + +static const struct pios_sbus_cfg pios_sbus_cfg = { + /* Inverter configuration */ + .inv = { + .gpio = GPIOB, + .init = { + .GPIO_Pin = GPIO_Pin_2, + .GPIO_Mode = GPIO_Mode_Out_PP, + .GPIO_Speed = GPIO_Speed_2MHz, + }, + }, + .gpio_clk_func = RCC_APB2PeriphClockCmd, + .gpio_clk_periph = RCC_APB2Periph_GPIOB, + .gpio_inv_enable = Bit_SET, +}; + +#endif /* PIOS_INCLUDE_SBUS */ + +#endif /* PIOS_INCLUDE_USART */ + +#if defined(PIOS_INCLUDE_COM) + +#include "pios_com_priv.h" + +#endif /* PIOS_INCLUDE_COM */ #if defined(PIOS_INCLUDE_RTC) /* @@ -430,11 +569,11 @@ const struct pios_usart_cfg pios_usart_gps_cfg = { void PIOS_RTC_IRQ_Handler (void); void RTC_IRQHandler() __attribute__ ((alias ("PIOS_RTC_IRQ_Handler"))); -const struct pios_rtc_cfg pios_rtc_main_cfg = { +static const struct pios_rtc_cfg pios_rtc_main_cfg = { .clksrc = RCC_RTCCLKSource_HSE_Div128, .prescaler = 100, .irq = { - .handler = PIOS_RTC_IRQ_Handler, + .handler = NULL, .init = { .NVIC_IRQChannel = RTC_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, @@ -451,174 +590,11 @@ void PIOS_RTC_IRQ_Handler (void) #endif -#if defined(PIOS_INCLUDE_SPEKTRUM) -/* - * SPEKTRUM USART - */ -void PIOS_USART_spektrum_irq_handler(void); -void PIOS_IRQH_SPEKTRUM() __attribute__ ((alias ("PIOS_USART_spektrum_irq_handler"))); -const struct pios_usart_cfg pios_usart_spektrum_cfg = { - .regs = PIOS_USART_SPEKTRUM, - .init = { - #if defined (PIOS_COM_SPEKTRUM_BAUDRATE) - .USART_BaudRate = PIOS_COM_SPEKTRUM_BAUDRATE, - #else - .USART_BaudRate = 115200, - #endif - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_No, - .USART_StopBits = USART_StopBits_1, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx, - }, - .irq = { - .handler = PIOS_USART_spektrum_irq_handler, - .init = { - .NVIC_IRQChannel = PIOS_IRQC_SPEKTRUM, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = PIOS_GPIO_SPEKTRUM, - .init = { - .GPIO_Pin = PIOS_RXIO_SPEKTRUM, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = PIOS_GPIO_SPEKTRUM, - .init = { - .GPIO_Pin = PIOS_TXIO_SPEKTRUM, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IN_FLOATING, - }, - }, -}; - -#include -static uint32_t pios_usart_spektrum_id; -void PIOS_USART_spektrum_irq_handler(void) -{ - PIOS_SPEKTRUM_irq_handler(pios_usart_spektrum_id); -} - -const struct pios_spektrum_cfg pios_spektrum_cfg = { - .pios_usart_spektrum_cfg = &pios_usart_spektrum_cfg, - .gpio_init = { //used for bind feature - .GPIO_Mode = GPIO_Mode_Out_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - .remap = 0, - .port = PIOS_GPIO_SPEKTRUM, - .pin = PIOS_RXIO_SPEKTRUM, -}; - -#endif /* PIOS_INCLUDE_SPEKTRUM */ - -#if defined(PIOS_INCLUDE_SBUS) -/* - * SBUS USART - */ -void PIOS_USART_sbus_irq_handler(void); -void PIOS_IRQH_SBUS() __attribute__ ((alias ("PIOS_USART_sbus_irq_handler"))); -const struct pios_usart_cfg pios_usart_sbus_cfg = { - .regs = PIOS_USART_SBUS, - .init = { - #if defined (PIOS_COM_SBUS_BAUDRATE) - .USART_BaudRate = PIOS_COM_SBUS_BAUDRATE, - #else - .USART_BaudRate = 100000, - #endif - .USART_WordLength = USART_WordLength_8b, - .USART_Parity = USART_Parity_Even, - .USART_StopBits = USART_StopBits_2, - .USART_HardwareFlowControl = USART_HardwareFlowControl_None, - .USART_Mode = USART_Mode_Rx, - }, - .irq = { - .handler = PIOS_USART_sbus_irq_handler, - .init = { - .NVIC_IRQChannel = PIOS_IRQC_SBUS, - .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, - .NVIC_IRQChannelSubPriority = 0, - .NVIC_IRQChannelCmd = ENABLE, - }, - }, - .rx = { - .gpio = PIOS_GPIO_SBUS, - .init = { - .GPIO_Pin = PIOS_RXIO_SBUS, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IPU, - }, - }, - .tx = { - .gpio = PIOS_GPIO_SBUS, - .init = { - .GPIO_Pin = PIOS_TXIO_SBUS, - .GPIO_Speed = GPIO_Speed_2MHz, - .GPIO_Mode = GPIO_Mode_IN_FLOATING, - }, - }, -}; - -static uint32_t pios_usart_sbus_id; -void PIOS_USART_sbus_irq_handler(void) -{ - PIOS_SBUS_irq_handler(pios_usart_sbus_id); -} - -#include -const struct pios_sbus_cfg pios_sbus_cfg = { - /* USART configuration structure */ - .pios_usart_sbus_cfg = &pios_usart_sbus_cfg, - - /* Invertor configuration */ - .gpio_clk_func = RCC_APB2PeriphClockCmd, - .gpio_clk_periph = RCC_APB2Periph_GPIOB, - .gpio_inv_port = GPIOB, - .gpio_inv_init = { - .GPIO_Pin = GPIO_Pin_2, - .GPIO_Mode = GPIO_Mode_Out_PP, - .GPIO_Speed = GPIO_Speed_2MHz, - }, - .gpio_inv_enable = Bit_SET, -}; - -#endif /* PIOS_INCLUDE_SBUS */ - -#if defined(PIOS_INCLUDE_TELEMETRY_RF) -static uint32_t pios_usart_telem_rf_id; -void PIOS_USART_telem_irq_handler(void) -{ - PIOS_USART_IRQ_Handler(pios_usart_telem_rf_id); -} -#endif /* PIOS_INCLUDE_TELEMETRY_RF */ - -#if defined(PIOS_INCLUDE_GPS) -static uint32_t pios_usart_gps_id; -void PIOS_USART_gps_irq_handler(void) -{ - PIOS_USART_IRQ_Handler(pios_usart_gps_id); -} -#endif /* PIOS_INCLUDE_GPS */ - -#endif /* PIOS_INCLUDE_USART */ - -#if defined(PIOS_INCLUDE_COM) - -#include "pios_com_priv.h" - -#endif /* PIOS_INCLUDE_COM */ - /* * Servo outputs */ #include -const struct pios_servo_channel pios_servo_channels[] = { +static const struct pios_servo_channel pios_servo_channels[] = { { .timer = TIM4, .port = GPIOB, @@ -684,13 +660,19 @@ const struct pios_servo_cfg pios_servo_cfg = { .num_channels = NELEMENTS(pios_servo_channels), }; +/* + * PPM Inputs + */ +#if defined(PIOS_INCLUDE_PPM) +#include +#endif /* * PWM Inputs */ #if defined(PIOS_INCLUDE_PWM) #include -const struct pios_pwm_channel pios_pwm_channels[] = { +static const struct pios_pwm_channel pios_pwm_channels[] = { { .timer = TIM4, .port = GPIOB, @@ -761,7 +743,7 @@ const struct pios_pwm_cfg pios_pwm_cfg = { }, .remap = 0, .irq = { - .handler = TIM2_IRQHandler, + .handler = NULL, .init = { .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, .NVIC_IRQChannelSubPriority = 0, @@ -798,7 +780,7 @@ void PIOS_I2C_main_adapter_er_irq_handler(void); void I2C2_EV_IRQHandler() __attribute__ ((alias ("PIOS_I2C_main_adapter_ev_irq_handler"))); void I2C2_ER_IRQHandler() __attribute__ ((alias ("PIOS_I2C_main_adapter_er_irq_handler"))); -const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { +static const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { .regs = I2C2, .init = { .I2C_Mode = I2C_Mode_I2C, @@ -826,7 +808,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { }, }, .event = { - .handler = PIOS_I2C_main_adapter_ev_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C2_EV_IRQn, @@ -836,7 +818,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { }, }, .error = { - .handler = PIOS_I2C_main_adapter_er_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C2_ER_IRQn, @@ -874,8 +856,6 @@ extern const struct pios_com_driver pios_usb_com_driver; uint32_t pios_com_telem_rf_id; uint32_t pios_com_telem_usb_id; uint32_t pios_com_gps_id; -uint32_t pios_com_spektrum_id; -uint32_t pios_com_sbus_id; /** * PIOS_Board_Init() @@ -885,8 +865,8 @@ uint32_t pios_com_sbus_id; void PIOS_Board_Init(void) { /* Delay system */ - PIOS_DELAY_Init(); - + PIOS_DELAY_Init(); + /* Set up the SPI interface to the serial flash */ if (PIOS_SPI_Init(&pios_spi_flash_accel_id, &pios_spi_flash_accel_cfg)) { PIOS_DEBUG_Assert(0); @@ -894,7 +874,7 @@ void PIOS_Board_Init(void) { PIOS_Flash_W25X_Init(pios_spi_flash_accel_id); PIOS_ADXL345_Attach(pios_spi_flash_accel_id); - + PIOS_FLASHFS_Init(); /* Initialize UAVObject libraries */ @@ -913,65 +893,195 @@ void PIOS_Board_Init(void) { /* Initialize the task monitor library */ TaskMonitorInitialize(); - /* Initialize the PiOS library */ -#if defined(PIOS_INCLUDE_COM) + /* Configure the main IO port */ + uint8_t hwsettings_cc_mainport; + HwSettingsCC_MainPortGet(&hwsettings_cc_mainport); + + switch (hwsettings_cc_mainport) { + case HWSETTINGS_CC_MAINPORT_DISABLED: + break; + case HWSETTINGS_CC_MAINPORT_TELEMETRY: #if defined(PIOS_INCLUDE_TELEMETRY_RF) - if (PIOS_USART_Init(&pios_usart_telem_rf_id, &pios_usart_telem_cfg)) { - PIOS_DEBUG_Assert(0); - } - if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_telem_rf_id)) { - PIOS_DEBUG_Assert(0); - } -#endif /* PIOS_INCLUDE_TELEMETRY_RF */ -#if defined(PIOS_INCLUDE_GPS) - if (PIOS_USART_Init(&pios_usart_gps_id, &pios_usart_gps_cfg)) { - PIOS_DEBUG_Assert(0); - } - if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_gps_id)) { - PIOS_DEBUG_Assert(0); - } -#endif /* PIOS_INCLUDE_GPS */ -#if defined(PIOS_INCLUDE_SPEKTRUM) - /* SPEKTRUM init must come before comms */ - PIOS_SPEKTRUM_Init(); - - if (PIOS_USART_Init(&pios_usart_spektrum_id, &pios_usart_spektrum_cfg)) { - PIOS_DEBUG_Assert(0); - } - if (PIOS_COM_Init(&pios_com_spektrum_id, &pios_usart_com_driver, pios_usart_spektrum_id)) { - PIOS_DEBUG_Assert(0); - } - for (uint8_t i = 0; i < PIOS_SPEKTRUM_NUM_INPUTS; i++) { - if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], - &pios_spektrum_rcvr_driver, - i)) { - pios_rcvr_max_channel++; - } else { - PIOS_DEBUG_Assert(0); + { + uint32_t pios_usart_telem_rf_id; + if (PIOS_USART_Init(&pios_usart_telem_rf_id, &pios_usart_telem_main_cfg)) { + PIOS_Assert(0); + } + if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_telem_rf_id)) { + PIOS_Assert(0); + } } - } -#endif +#endif /* PIOS_INCLUDE_TELEMETRY_RF */ + break; + case HWSETTINGS_CC_MAINPORT_SBUS: #if defined(PIOS_INCLUDE_SBUS) - PIOS_SBUS_Init(); + { + PIOS_SBUS_Init(&pios_sbus_cfg); - if (PIOS_USART_Init(&pios_usart_sbus_id, &pios_usart_sbus_cfg)) { - PIOS_DEBUG_Assert(0); - } - if (PIOS_COM_Init(&pios_com_sbus_id, &pios_usart_com_driver, pios_usart_sbus_id)) { - PIOS_DEBUG_Assert(0); - } - for (uint8_t i = 0; i < SBUS_NUMBER_OF_CHANNELS; i++) { - if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], - &pios_sbus_rcvr_driver, - i)) { - pios_rcvr_max_channel++; - } else { - PIOS_DEBUG_Assert(0); + uint32_t pios_usart_sbus_id; + if (PIOS_USART_Init(&pios_usart_sbus_id, &pios_usart_sbus_main_cfg)) { + PIOS_Assert(0); + } } +#endif /* PIOS_INCLUDE_SBUS */ + break; + case HWSETTINGS_CC_MAINPORT_GPS: +#if defined(PIOS_INCLUDE_GPS) + { + uint32_t pios_usart_gps_id; + if (PIOS_USART_Init(&pios_usart_gps_id, &pios_usart_gps_main_cfg)) { + PIOS_Assert(0); + } + if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_gps_id)) { + PIOS_Assert(0); + } + } +#endif /* PIOS_INCLUDE_GPS */ + break; + case HWSETTINGS_CC_MAINPORT_SPEKTRUM: +#if defined(PIOS_INCLUDE_SPEKTRUM) + { + /* SPEKTRUM init must come before usart init since it may use Rx pin for bind */ + PIOS_SPEKTRUM_Init(&pios_spektrum_main_cfg, false); + + uint32_t pios_usart_spektrum_id; + if (PIOS_USART_Init(&pios_usart_spektrum_id, &pios_usart_spektrum_main_cfg)) { + PIOS_Assert(0); + } + } +#endif /* PIOS_INCLUDE_SPEKTRUM */ + break; + case HWSETTINGS_CC_MAINPORT_COMAUX: + break; } + /* Configure the flexi port */ + uint8_t hwsettings_cc_flexiport; + HwSettingsCC_FlexiPortGet(&hwsettings_cc_flexiport); + + switch (hwsettings_cc_flexiport) { + case HWSETTINGS_CC_FLEXIPORT_DISABLED: + break; + case HWSETTINGS_CC_FLEXIPORT_TELEMETRY: +#if defined(PIOS_INCLUDE_TELEMETRY_RF) + { + uint32_t pios_usart_telem_rf_id; + if (PIOS_USART_Init(&pios_usart_telem_rf_id, &pios_usart_telem_flexi_cfg)) { + PIOS_Assert(0); + } + if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_telem_rf_id)) { + PIOS_Assert(0); + } + } +#endif /* PIOS_INCLUDE_TELEMETRY_RF */ + break; + case HWSETTINGS_CC_FLEXIPORT_GPS: +#if defined(PIOS_INCLUDE_GPS) + { + uint32_t pios_usart_gps_id; + if (PIOS_USART_Init(&pios_usart_gps_id, &pios_usart_gps_flexi_cfg)) { + PIOS_Assert(0); + } + if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_gps_id)) { + PIOS_Assert(0); + } + } +#endif /* PIOS_INCLUDE_GPS */ + break; + case HWSETTINGS_CC_FLEXIPORT_SPEKTRUM: +#if defined(PIOS_INCLUDE_SPEKTRUM) + { + /* SPEKTRUM init must come before usart init since it may use Rx pin for bind */ + PIOS_SPEKTRUM_Init(&pios_spektrum_flexi_cfg, false); + + uint32_t pios_usart_spektrum_id; + if (PIOS_USART_Init(&pios_usart_spektrum_id, &pios_usart_spektrum_flexi_cfg)) { + PIOS_Assert(0); + } + } +#endif /* PIOS_INCLUDE_SPEKTRUM */ + break; + case HWSETTINGS_CC_FLEXIPORT_COMAUX: + break; + case HWSETTINGS_CC_FLEXIPORT_I2C: +#if defined(PIOS_INCLUDE_I2C) + { + if (PIOS_I2C_Init(&pios_i2c_main_adapter_id, &pios_i2c_main_adapter_cfg)) { + PIOS_Assert(0); + } + } +#endif /* PIOS_INCLUDE_I2C */ + break; + } + + /* Configure the selected receiver */ + uint8_t manualcontrolsettings_inputmode; + ManualControlSettingsInputModeGet(&manualcontrolsettings_inputmode); + + switch (manualcontrolsettings_inputmode) { + case MANUALCONTROLSETTINGS_INPUTMODE_PWM: +#if defined(PIOS_INCLUDE_PWM) + PIOS_PWM_Init(); + for (uint8_t i = 0; i < PIOS_PWM_NUM_INPUTS; i++) { + if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], + &pios_pwm_rcvr_driver, + i)) { + pios_rcvr_max_channel++; + } else { + PIOS_DEBUG_Assert(0); + } + } +#endif /* PIOS_INCLUDE_PWM */ + break; + case MANUALCONTROLSETTINGS_INPUTMODE_PPM: +#if defined(PIOS_INCLUDE_PPM) + PIOS_PPM_Init(); + for (uint8_t i = 0; i < PIOS_PPM_NUM_INPUTS; i++) { + if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], + &pios_ppm_rcvr_driver, + i)) { + pios_rcvr_max_channel++; + } else { + PIOS_DEBUG_Assert(0); + } + } +#endif /* PIOS_INCLUDE_PPM */ + break; + case MANUALCONTROLSETTINGS_INPUTMODE_SPEKTRUM: +#if defined(PIOS_INCLUDE_SPEKTRUM) + if (hwsettings_cc_mainport == HWSETTINGS_CC_MAINPORT_SPEKTRUM || + hwsettings_cc_flexiport == HWSETTINGS_CC_FLEXIPORT_SPEKTRUM) { + for (uint8_t i = 0; i < PIOS_SPEKTRUM_NUM_INPUTS; i++) { + if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], + &pios_spektrum_rcvr_driver, + i)) { + pios_rcvr_max_channel++; + } else { + PIOS_Assert(0); + } + } + } +#endif /* PIOS_INCLUDE_SPEKTRUM */ + break; +#if THIS_IS_NOT_YET_A_VALID_INPUT_MODE + case MANUALCONTROLSETTINGS_INPUTMODE_SBUS: +#if defined(PIOS_INCLUDE_SBUS) + if (hwsettings_cc_mainport == HWSETTINGS_CC_MAINPORT_SBUS || + hwsettings_cc_flexiport == HWSETTINGS_CC_FLEXIPORT_SBUS) { + for (uint8_t i = 0; i < PIOS_SBUS_NUM_INPUTS; i++) { + if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], + &pios_sbus_rcvr_driver, + i)) { + pios_rcvr_max_channel++; + } else { + PIOS_Assert(0); + } + } + } #endif /* PIOS_INCLUDE_SBUS */ -#endif /* PIOS_INCLUDE_COM */ + break; +#endif /* THIS_IS_NOT_YET_A_VALID_INPUT_MODE */ + } /* Remap AFIO pin */ GPIO_PinRemapConfig( GPIO_Remap_SWJ_NoJTRST, ENABLE); @@ -980,36 +1090,6 @@ void PIOS_Board_Init(void) { PIOS_ADC_Init(); PIOS_GPIO_Init(); -#if defined(PIOS_INCLUDE_PWM) -#if (PIOS_PWM_NUM_INPUTS > PIOS_RCVR_MAX_DEVS) -#error More receiver inputs than available devices -#endif - PIOS_PWM_Init(); - for (uint8_t i = 0; i < PIOS_PWM_NUM_INPUTS; i++) { - if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], - &pios_pwm_rcvr_driver, - i)) { - pios_rcvr_max_channel++; - } else { - PIOS_DEBUG_Assert(0); - } - } -#endif -#if defined(PIOS_INCLUDE_PPM) -#if (PIOS_PPM_NUM_INPUTS > PIOS_RCVR_MAX_DEVS) -#error More receiver inputs than available devices -#endif - PIOS_PPM_Init(); - for (uint8_t i = 0; i < PIOS_PPM_NUM_INPUTS; i++) { - if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], - &pios_ppm_rcvr_driver, - i)) { - pios_rcvr_max_channel++; - } else { - PIOS_DEBUG_Assert(0); - } - } -#endif #if defined(PIOS_INCLUDE_USB_HID) PIOS_USB_HID_Init(0); #if defined(PIOS_INCLUDE_COM) @@ -1017,13 +1097,8 @@ void PIOS_Board_Init(void) { PIOS_DEBUG_Assert(0); } #endif /* PIOS_INCLUDE_COM */ -#endif +#endif /* PIOS_INCLUDE_USB_HID */ -#if defined(PIOS_INCLUDE_I2C) - if (PIOS_I2C_Init(&pios_i2c_main_adapter_id, &pios_i2c_main_adapter_cfg)) { - PIOS_DEBUG_Assert(0); - } -#endif /* PIOS_INCLUDE_I2C */ PIOS_IAP_Init(); PIOS_WDG_Init(); } diff --git a/flight/INS/pios_board.c b/flight/INS/pios_board.c index 524416cb1..7010b7f00 100644 --- a/flight/INS/pios_board.c +++ b/flight/INS/pios_board.c @@ -61,7 +61,7 @@ static const struct pios_spi_cfg pios_spi_op_mag_cfg = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_op_mag_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC4 | DMA1_FLAG_TE4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4), @@ -175,7 +175,7 @@ static const struct pios_spi_cfg pios_spi_accel_cfg = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_accel_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC2 | DMA1_FLAG_TE2 | DMA1_FLAG_HT2 | DMA1_FLAG_GL2), .init = { .NVIC_IRQChannel = DMA1_Channel2_IRQn, @@ -265,10 +265,7 @@ void PIOS_SPI_accel_irq_handler(void) /* * GPS USART */ -void PIOS_USART_gps_irq_handler(void); -void USART1_IRQHandler() - __attribute__ ((alias("PIOS_USART_gps_irq_handler"))); -const struct pios_usart_cfg pios_usart_gps_cfg = { +static const struct pios_usart_cfg pios_usart_gps_cfg = { .regs = USART1, .init = { #if defined (PIOS_USART_BAUDRATE) @@ -284,7 +281,7 @@ const struct pios_usart_cfg pios_usart_gps_cfg = { .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_gps_irq_handler, + .handler = NULL, .init = { .NVIC_IRQChannel = USART1_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, @@ -310,22 +307,13 @@ const struct pios_usart_cfg pios_usart_gps_cfg = { }, }; -static uint32_t pios_usart_gps_id; -void PIOS_USART_gps_irq_handler(void) -{ - PIOS_USART_IRQ_Handler(pios_usart_gps_id); -} - #endif /* PIOS_INCLUDE_GPS */ #ifdef PIOS_COM_AUX /* * AUX USART */ -void PIOS_USART_aux_irq_handler(void); -void USART4_IRQHandler() - __attribute__ ((alias("PIOS_USART_aux_irq_handler"))); -const struct pios_usart_cfg pios_usart_aux_cfg = { +static const struct pios_usart_cfg pios_usart_aux_cfg = { .regs = USART4, .init = { #if defined (PIOS_USART_BAUDRATE) @@ -341,7 +329,7 @@ const struct pios_usart_cfg pios_usart_aux_cfg = { .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_aux_irq_handler, + .handler = NULL, .init = { .NVIC_IRQChannel = USART4_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, @@ -367,12 +355,6 @@ const struct pios_usart_cfg pios_usart_aux_cfg = { }, }; -static uint32_t pios_usart_aux_id; -void PIOS_USART_aux_irq_handler(void) -{ - PIOS_USART_IRQ_Handler(pios_usart_aux_id); -} - #endif /* PIOS_COM_AUX */ @@ -391,7 +373,7 @@ void I2C1_EV_IRQHandler() void I2C1_ER_IRQHandler() __attribute__ ((alias("PIOS_I2C_pres_mag_adapter_er_irq_handler"))); -const struct pios_i2c_adapter_cfg pios_i2c_pres_mag_adapter_cfg = { +static const struct pios_i2c_adapter_cfg pios_i2c_pres_mag_adapter_cfg = { .regs = I2C1, .init = { .I2C_Mode = I2C_Mode_I2C, @@ -419,7 +401,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_pres_mag_adapter_cfg = { }, }, .event = { - .handler = PIOS_I2C_pres_mag_adapter_ev_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C1_EV_IRQn, @@ -429,7 +411,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_pres_mag_adapter_cfg = { }, }, .error = { - .handler = PIOS_I2C_pres_mag_adapter_er_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C1_ER_IRQn, @@ -459,7 +441,7 @@ void PIOS_I2C_gyro_adapter_er_irq_handler(void); void I2C2_EV_IRQHandler() __attribute__ ((alias ("PIOS_I2C_gyro_adapter_ev_irq_handler"))); void I2C2_ER_IRQHandler() __attribute__ ((alias ("PIOS_I2C_gyro_adapter_er_irq_handler"))); -const struct pios_i2c_adapter_cfg pios_i2c_gyro_adapter_cfg = { +static const struct pios_i2c_adapter_cfg pios_i2c_gyro_adapter_cfg = { .regs = I2C2, .init = { .I2C_Mode = I2C_Mode_I2C, @@ -487,7 +469,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_gyro_adapter_cfg = { }, }, .event = { - .handler = PIOS_I2C_gyro_adapter_ev_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C2_EV_IRQn, @@ -497,7 +479,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_gyro_adapter_cfg = { }, }, .error = { - .handler = PIOS_I2C_gyro_adapter_er_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C2_ER_IRQn, @@ -547,6 +529,7 @@ void PIOS_Board_Init(void) { #if defined(PIOS_INCLUDE_COM) #if defined(PIOS_INCLUDE_GPS) + uint32_t pios_usart_gps_id; if (PIOS_USART_Init(&pios_usart_gps_id, &pios_usart_gps_cfg)) { PIOS_DEBUG_Assert(0); } diff --git a/flight/OpenPilot/Makefile b/flight/OpenPilot/Makefile index 83b179641..8c4322381 100644 --- a/flight/OpenPilot/Makefile +++ b/flight/OpenPilot/Makefile @@ -43,10 +43,6 @@ ENABLE_DEBUG_PINS ?= NO # Set to Yes to enable the AUX UART which is mapped on the S1 (Tx) and S2 (Rx) servo outputs ENABLE_AUX_UART ?= NO -USE_SPEKTRUM ?= NO -USE_SBUS ?= NO - - # Set to YES when using Code Sourcery toolchain CODE_SOURCERY ?= YES @@ -366,14 +362,6 @@ ifeq ($(ENABLE_AUX_UART), YES) CDEFS += -DPIOS_ENABLE_AUX_UART endif -ifeq ($(USE_SPEKTRUM), YES) -CDEFS += -DUSE_SPEKTRUM -endif -ifeq ($(USE_SBUS), YES) -CDEFS += -DUSE_SBUS -endif - - # Place project-specific -D and/or -U options for # Assembler with preprocessor here. #ADEFS = -DUSE_IRQ_ASM_WRAPPER diff --git a/flight/OpenPilot/System/inc/pios_config.h b/flight/OpenPilot/System/inc/pios_config.h index 215d0fadb..3ea502a1a 100644 --- a/flight/OpenPilot/System/inc/pios_config.h +++ b/flight/OpenPilot/System/inc/pios_config.h @@ -44,14 +44,10 @@ #define PIOS_INCLUDE_RCVR -#if defined(USE_SPEKTRUM) #define PIOS_INCLUDE_SPEKTRUM -#elif defined(USE_SBUS) -#define PIOS_INCLUDE_SBUS -#else -//#define PIOS_INCLUDE_PPM +//#define PIOS_INCLUDE_SBUS #define PIOS_INCLUDE_PWM -#endif +//#define PIOS_INCLUDE_PPM #define PIOS_INCLUDE_SERVO #define PIOS_INCLUDE_SPI diff --git a/flight/OpenPilot/System/pios_board.c b/flight/OpenPilot/System/pios_board.c index 3953f03d4..c9d800eb9 100644 --- a/flight/OpenPilot/System/pios_board.c +++ b/flight/OpenPilot/System/pios_board.c @@ -46,7 +46,7 @@ void PIOS_SPI_sdcard_irq_handler(void); void DMA1_Channel2_IRQHandler() __attribute__ ((alias ("PIOS_SPI_sdcard_irq_handler"))); void DMA1_Channel3_IRQHandler() __attribute__ ((alias ("PIOS_SPI_sdcard_irq_handler"))); -const struct pios_spi_cfg pios_spi_sdcard_cfg = { +static const struct pios_spi_cfg pios_spi_sdcard_cfg = { .regs = SPI1, .init = { .SPI_Mode = SPI_Mode_Master, @@ -63,7 +63,7 @@ const struct pios_spi_cfg pios_spi_sdcard_cfg = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_sdcard_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC2 | DMA1_FLAG_TE2 | DMA1_FLAG_HT2 | DMA1_FLAG_GL2), .init = { .NVIC_IRQChannel = DMA1_Channel2_IRQn, @@ -144,7 +144,7 @@ const struct pios_spi_cfg pios_spi_sdcard_cfg = { void PIOS_SPI_ahrs_irq_handler(void); void DMA1_Channel4_IRQHandler() __attribute__ ((alias ("PIOS_SPI_ahrs_irq_handler"))); void DMA1_Channel5_IRQHandler() __attribute__ ((alias ("PIOS_SPI_ahrs_irq_handler"))); -const struct pios_spi_cfg pios_spi_ahrs_cfg = { +static const struct pios_spi_cfg pios_spi_ahrs_cfg = { .regs = SPI2, .init = { .SPI_Mode = SPI_Mode_Master, @@ -162,7 +162,7 @@ const struct pios_spi_cfg pios_spi_ahrs_cfg = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_ahrs_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC4 | DMA1_FLAG_TE4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4), .init = { .NVIC_IRQChannel = DMA1_Channel4_IRQn, @@ -258,11 +258,11 @@ void PIOS_SPI_ahrs_irq_handler(void) extern void PIOS_ADC_handler(void); void DMA1_Channel1_IRQHandler() __attribute__ ((alias("PIOS_ADC_handler"))); // Remap the ADC DMA handler to this one -const struct pios_adc_cfg pios_adc_cfg = { +static const struct pios_adc_cfg pios_adc_cfg = { .dma = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_ADC_DMA_Handler, + .handler = NULL, .flags = (DMA1_FLAG_TC1 | DMA1_FLAG_TE1 | DMA1_FLAG_HT1 | DMA1_FLAG_GL1), .init = { .NVIC_IRQChannel = DMA1_Channel1_IRQn, @@ -310,9 +310,7 @@ void PIOS_ADC_handler() { /* * Telemetry USART */ -void PIOS_USART_telem_irq_handler(void); -void USART2_IRQHandler() __attribute__ ((alias ("PIOS_USART_telem_irq_handler"))); -const struct pios_usart_cfg pios_usart_telem_cfg = { +static const struct pios_usart_cfg pios_usart_telem_cfg = { .regs = USART2, .init = { #if defined (PIOS_COM_TELEM_BAUDRATE) @@ -327,7 +325,7 @@ const struct pios_usart_cfg pios_usart_telem_cfg = { .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_telem_irq_handler, + .handler = NULL, .init = { .NVIC_IRQChannel = USART2_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, @@ -356,9 +354,7 @@ const struct pios_usart_cfg pios_usart_telem_cfg = { /* * GPS USART */ -void PIOS_USART_gps_irq_handler(void); -void USART3_IRQHandler() __attribute__ ((alias ("PIOS_USART_gps_irq_handler"))); -const struct pios_usart_cfg pios_usart_gps_cfg = { +static const struct pios_usart_cfg pios_usart_gps_cfg = { .regs = USART3, .remap = GPIO_PartialRemap_USART3, .init = { @@ -374,7 +370,7 @@ const struct pios_usart_cfg pios_usart_gps_cfg = { .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_gps_irq_handler, + .handler = NULL, .init = { .NVIC_IRQChannel = USART3_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, @@ -404,9 +400,7 @@ const struct pios_usart_cfg pios_usart_gps_cfg = { /* * AUX USART */ -void PIOS_USART_aux_irq_handler(void); -void USART1_IRQHandler() __attribute__ ((alias ("PIOS_USART_aux_irq_handler"))); -const struct pios_usart_cfg pios_usart_aux_cfg = { +static const struct pios_usart_cfg pios_usart_aux_cfg = { .regs = USART1, .init = { #if defined (PIOS_COM_AUX_BAUDRATE) @@ -422,7 +416,7 @@ const struct pios_usart_cfg pios_usart_aux_cfg = { .USART_Mode = USART_Mode_Rx | USART_Mode_Tx, }, .irq = { - .handler = PIOS_USART_aux_irq_handler, + .handler = NULL, .init = { .NVIC_IRQChannel = USART1_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, @@ -458,11 +452,11 @@ const struct pios_usart_cfg pios_usart_aux_cfg = { void PIOS_RTC_IRQ_Handler (void); void RTC_IRQHandler() __attribute__ ((alias ("PIOS_RTC_IRQ_Handler"))); -const struct pios_rtc_cfg pios_rtc_main_cfg = { +static const struct pios_rtc_cfg pios_rtc_main_cfg = { .clksrc = RCC_RTCCLKSource_HSE_Div128, .prescaler = 100, .irq = { - .handler = PIOS_RTC_IRQ_Handler, + .handler = NULL, .init = { .NVIC_IRQChannel = RTC_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, @@ -483,9 +477,9 @@ void PIOS_RTC_IRQ_Handler (void) /* * SPEKTRUM USART */ -void PIOS_USART_spektrum_irq_handler(void); -void USART1_IRQHandler() __attribute__ ((alias ("PIOS_USART_spektrum_irq_handler"))); -const struct pios_usart_cfg pios_usart_spektrum_cfg = { +#include + +static const struct pios_usart_cfg pios_usart_spektrum_cfg = { .regs = USART1, .init = { #if defined (PIOS_COM_SPEKTRUM_BAUDRATE) @@ -500,7 +494,7 @@ const struct pios_usart_cfg pios_usart_spektrum_cfg = { .USART_Mode = USART_Mode_Rx, }, .irq = { - .handler = PIOS_USART_spektrum_irq_handler, + .handler = PIOS_SPEKTRUM_irq_handler, .init = { .NVIC_IRQChannel = USART1_IRQn, .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH, @@ -533,15 +527,16 @@ void PIOS_USART_spektrum_irq_handler(void) PIOS_SPEKTRUM_irq_handler(pios_usart_spektrum_id); } -const struct pios_spektrum_cfg pios_spektrum_cfg = { - .pios_usart_spektrum_cfg = &pios_usart_spektrum_cfg, - .gpio_init = { //used for bind feature - .GPIO_Mode = GPIO_Mode_Out_PP, - .GPIO_Speed = GPIO_Speed_2MHz, +static const struct pios_spektrum_cfg pios_spektrum_cfg = { + .bind = { + .gpio = GPIOA, + .init = { + .GPIO_Pin = GPIO_Pin_10, + .GPIO_Speed = GPIO_Speed_2MHz, + .GPIO_Mode = GPIO_Mode_Out_PP, + }, }, .remap = 0, - .port = GPIOA, - .pin = GPIO_Pin_10, }; #endif /* PIOS_COM_SPEKTRUM */ @@ -550,33 +545,6 @@ const struct pios_spektrum_cfg pios_spektrum_cfg = { #error PIOS_INCLUDE_SBUS not implemented #endif /* PIOS_INCLUDE_SBUS */ -static uint32_t pios_usart_telem_rf_id; -void PIOS_USART_telem_irq_handler(void) -{ - PIOS_USART_IRQ_Handler(pios_usart_telem_rf_id); -} - -static uint32_t pios_usart_gps_id; -void PIOS_USART_gps_irq_handler(void) -{ -#ifdef USART_GPS_DEBUG_PIN - PIOS_DEBUG_PinHigh(USART_GPS_DEBUG_PIN); -#endif - PIOS_USART_IRQ_Handler(pios_usart_gps_id); -#ifdef USART_GPS_DEBUG_PIN - PIOS_DEBUG_PinLow(USART_GPS_DEBUG_PIN); -#endif - -} - -#ifdef PIOS_COM_AUX -static uint32_t pios_usart_aux_id; -void PIOS_USART_aux_irq_handler(void) -{ - PIOS_USART_IRQ_Handler(pios_usart_aux_id); -} -#endif - #endif /* PIOS_INCLUDE_USART */ #if defined(PIOS_INCLUDE_COM) @@ -589,7 +557,7 @@ void PIOS_USART_aux_irq_handler(void) * Pios servo configuration structures */ #include -const struct pios_servo_channel pios_servo_channels[] = { +static const struct pios_servo_channel pios_servo_channels[] = { { .timer = TIM4, .port = GPIOB, @@ -673,7 +641,7 @@ const struct pios_servo_cfg pios_servo_cfg = { */ #if defined(PIOS_INCLUDE_PWM) #include -const struct pios_pwm_channel pios_pwm_channels[] = { +static const struct pios_pwm_channel pios_pwm_channels[] = { { .timer = TIM1, .port = GPIOA, @@ -758,7 +726,7 @@ const struct pios_pwm_cfg pios_pwm_cfg = { }, .remap = GPIO_PartialRemap_TIM3, .irq = { - .handler = TIM1_CC_IRQHandler, + .handler = NULL, .init = { .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, .NVIC_IRQChannelSubPriority = 0, @@ -789,7 +757,7 @@ void PIOS_TIM5_irq_handler() #include void TIM6_IRQHandler(); void TIM6_IRQHandler() __attribute__ ((alias ("PIOS_TIM6_irq_handler"))); -const struct pios_ppmsv_cfg pios_ppmsv_cfg = { +static const struct pios_ppmsv_cfg pios_ppmsv_cfg = { .tim_base_init = { .TIM_Prescaler = (PIOS_MASTER_CLOCK / 1000000) - 1, /* For 1 uS accuracy */ .TIM_ClockDivision = TIM_CKD_DIV1, @@ -798,7 +766,7 @@ const struct pios_ppmsv_cfg pios_ppmsv_cfg = { .TIM_RepetitionCounter = 0x0000, }, .irq = { - .handler = TIM6_IRQHandler, + .handler = NULL, .init = { .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, .NVIC_IRQChannelSubPriority = 0, @@ -816,7 +784,7 @@ void PIOS_TIM6_irq_handler(void) void TIM1_CC_IRQHandler(); void TIM1_CC_IRQHandler() __attribute__ ((alias ("PIOS_TIM1_CC_irq_handler"))); -const struct pios_ppm_cfg pios_ppm_cfg = { +static const struct pios_ppm_cfg pios_ppm_cfg = { .tim_base_init = { .TIM_Prescaler = (PIOS_MASTER_CLOCK / 1000000) - 1, /* For 1 uS accuracy */ .TIM_ClockDivision = TIM_CKD_DIV1, @@ -838,7 +806,7 @@ const struct pios_ppm_cfg pios_ppm_cfg = { }, .remap = 0, .irq = { - .handler = TIM1_CC_IRQHandler, + .handler = NULL, .init = { .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_MID, .NVIC_IRQChannelSubPriority = 0, @@ -871,7 +839,7 @@ void PIOS_I2C_main_adapter_er_irq_handler(void); void I2C2_EV_IRQHandler() __attribute__ ((alias ("PIOS_I2C_main_adapter_ev_irq_handler"))); void I2C2_ER_IRQHandler() __attribute__ ((alias ("PIOS_I2C_main_adapter_er_irq_handler"))); -const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { +static const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { .regs = I2C2, .init = { .I2C_Mode = I2C_Mode_I2C, @@ -899,7 +867,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { }, }, .event = { - .handler = PIOS_I2C_main_adapter_ev_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C2_EV_IRQn, @@ -909,7 +877,7 @@ const struct pios_i2c_adapter_cfg pios_i2c_main_adapter_cfg = { }, }, .error = { - .handler = PIOS_I2C_main_adapter_er_irq_handler, + .handler = NULL, .flags = 0, /* FIXME: check this */ .init = { .NVIC_IRQChannel = I2C2_ER_IRQn, @@ -1093,19 +1061,25 @@ void PIOS_Board_Init(void) { /* Initialize the PiOS library */ #if defined(PIOS_INCLUDE_COM) +#if defined(PIOS_INCLUDE_TELEMETRY_RF) + uint32_t pios_usart_telem_rf_id; if (PIOS_USART_Init(&pios_usart_telem_rf_id, &pios_usart_telem_cfg)) { PIOS_DEBUG_Assert(0); } if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_telem_rf_id)) { PIOS_DEBUG_Assert(0); } +#endif /* PIOS_INCLUDE_TELEMETRY_RF */ +#if defined(PIOS_INCLUDE_GPS) + uint32_t pios_usart_gps_id; if (PIOS_USART_Init(&pios_usart_gps_id, &pios_usart_gps_cfg)) { PIOS_DEBUG_Assert(0); } if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_gps_id)) { PIOS_DEBUG_Assert(0); } +#endif /* PIOS_INCLUDE_GPS */ #endif PIOS_Servo_Init(); @@ -1117,14 +1091,12 @@ void PIOS_Board_Init(void) { #error More receiver inputs than available devices #endif /* SPEKTRUM init must come before comms */ - PIOS_SPEKTRUM_Init(); + PIOS_SPEKTRUM_Init(&pios_spektrum_cfg, false); + uint32_t pios_usart_spektrum_id; if (PIOS_USART_Init(&pios_usart_spektrum_id, &pios_usart_spektrum_cfg)) { PIOS_DEBUG_Assert(0); } - if (PIOS_COM_Init(&pios_com_spektrum_id, &pios_usart_com_driver, pios_usart_spektrum_id)) { - PIOS_DEBUG_Assert(0); - } for (uint8_t i = 0; i < PIOS_SPEKTRUM_NUM_INPUTS; i++) { if (!PIOS_RCVR_Init(&pios_rcvr_channel_to_id_map[pios_rcvr_max_channel], &pios_spektrum_rcvr_driver, diff --git a/flight/PiOS/Boards/STM32103CB_CC_Rev1.h b/flight/PiOS/Boards/STM32103CB_CC_Rev1.h index 993d08c78..b83114e8a 100644 --- a/flight/PiOS/Boards/STM32103CB_CC_Rev1.h +++ b/flight/PiOS/Boards/STM32103CB_CC_Rev1.h @@ -235,7 +235,6 @@ extern uint32_t pios_com_sbus_id; // Receiver PPM input //------------------------- #define PIOS_PPM_NUM_INPUTS 6 //Could be more if needed -#define PIOS_PPM_SUPV_ENABLED 1 //------------------------- // Receiver PWM input diff --git a/flight/PiOS/STM32F10x/pios_sbus.c b/flight/PiOS/STM32F10x/pios_sbus.c index 698beac94..06fb4d5f8 100644 --- a/flight/PiOS/STM32F10x/pios_sbus.c +++ b/flight/PiOS/STM32F10x/pios_sbus.c @@ -135,17 +135,17 @@ static void process_byte(uint8_t b) /** * Initialise S.Bus receiver interface */ -void PIOS_SBUS_Init(void) +void PIOS_SBUS_Init(const struct pios_sbus_cfg *cfg) { - /* Enable USART input invertor clock and enable the invertor */ - (*pios_sbus_cfg.gpio_clk_func)(pios_sbus_cfg.gpio_clk_periph, ENABLE); - GPIO_Init(pios_sbus_cfg.gpio_inv_port, &pios_sbus_cfg.gpio_inv_init); - GPIO_WriteBit(pios_sbus_cfg.gpio_inv_port, - pios_sbus_cfg.gpio_inv_init.GPIO_Pin, - pios_sbus_cfg.gpio_inv_enable); + /* Enable inverter clock and enable the inverter */ + (*cfg->gpio_clk_func)(cfg->gpio_clk_periph, ENABLE); + GPIO_Init(cfg->inv.gpio, &cfg->inv.init); + GPIO_WriteBit(cfg->inv.gpio, + cfg->inv.init.GPIO_Pin, + cfg->gpio_inv_enable); if (!PIOS_RTC_RegisterTickCallback(PIOS_SBUS_Supervisor, 0)) { - PIOS_DEBUG_Assert(0); + PIOS_Assert(0); } } @@ -169,9 +169,14 @@ static int32_t PIOS_SBUS_Get(uint32_t chan_id) */ void PIOS_SBUS_irq_handler(uint32_t usart_id) { + /* Grab the config for this device from the underlying USART device */ + const struct pios_usart_cfg * cfg; + cfg = PIOS_USART_GetConfig(usart_id); + PIOS_Assert(cfg); + /* by always reading DR after SR make sure to clear any error interrupts */ - volatile uint16_t sr = pios_sbus_cfg.pios_usart_sbus_cfg->regs->SR; - volatile uint8_t b = pios_sbus_cfg.pios_usart_sbus_cfg->regs->DR; + volatile uint16_t sr = cfg->regs->SR; + volatile uint8_t b = cfg->regs->DR; /* process received byte if one has arrived */ if (sr & USART_SR_RXNE) { @@ -183,7 +188,7 @@ void PIOS_SBUS_irq_handler(uint32_t usart_id) /* ignore TXE interrupts */ if (sr & USART_SR_TXE) { /* disable TXE interrupt (TXEIE=0) */ - USART_ITConfig(pios_sbus_cfg.pios_usart_sbus_cfg->regs, USART_IT_TXE, DISABLE); + USART_ITConfig(cfg->regs, USART_IT_TXE, DISABLE); } } diff --git a/flight/PiOS/STM32F10x/pios_spektrum.c b/flight/PiOS/STM32F10x/pios_spektrum.c index 4372fb4ef..57ce7de11 100644 --- a/flight/PiOS/STM32F10x/pios_spektrum.c +++ b/flight/PiOS/STM32F10x/pios_spektrum.c @@ -34,12 +34,6 @@ #include "pios_spektrum_priv.h" #if defined(PIOS_INCLUDE_SPEKTRUM) -#if defined(PIOS_INCLUDE_PWM) || defined(PIOS_INCLUDE_SBUS) -#error "Both SPEKTRUM and either of PWM or SBUS inputs defined, choose only one" -#endif -#if defined(PIOS_COM_AUX) -#error "AUX com cannot be used with SPEKTRUM" -#endif /** * @Note Framesyncing: @@ -65,15 +59,16 @@ uint8_t sync_of = 0; uint16_t supv_timer=0; static void PIOS_SPEKTRUM_Supervisor(uint32_t spektrum_id); +static bool PIOS_SPEKTRUM_Bind(const struct pios_spektrum_cfg * cfg); /** * Bind and Initialise Spektrum satellite receiver */ -void PIOS_SPEKTRUM_Init(void) +void PIOS_SPEKTRUM_Init(const struct pios_spektrum_cfg * cfg, bool bind) { // TODO: need setting flag for bind on next powerup - if (0) { - PIOS_SPEKTRUM_Bind(); + if (bind) { + PIOS_SPEKTRUM_Bind(cfg); } if (!PIOS_RTC_RegisterTickCallback(PIOS_SPEKTRUM_Supervisor, 0)) { @@ -98,48 +93,45 @@ static int32_t PIOS_SPEKTRUM_Get(uint32_t chan_id) /** * Spektrum bind function -* \output 1 Successful bind -* \output 0 Bind failed -* \note Applications shouldn't call these functions directly +* \output true Successful bind +* \output false Bind failed */ -uint8_t PIOS_SPEKTRUM_Bind(void) +static bool PIOS_SPEKTRUM_Bind(const struct pios_spektrum_cfg * cfg) { - GPIO_InitTypeDef GPIO_InitStructure = pios_spektrum_cfg.gpio_init; - GPIO_InitStructure.GPIO_Pin = pios_spektrum_cfg.pin; - GPIO_Init(pios_spektrum_cfg.port, &GPIO_InitStructure); + GPIO_Init(cfg->bind.gpio, &cfg->bind.init); - pios_spektrum_cfg.port->BRR = pios_spektrum_cfg.pin; + GPIO_ResetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); //PIOS_DELAY_WaitmS(75); /* RX line, drive high for 10us */ - pios_spektrum_cfg.port->BSRR = pios_spektrum_cfg.pin; + GPIO_SetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(10); /* RX line, drive low for 120us */ - pios_spektrum_cfg.port->BRR = pios_spektrum_cfg.pin; + GPIO_ResetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(120); /* RX line, drive high for 120us */ - pios_spektrum_cfg.port->BSRR = pios_spektrum_cfg.pin; + GPIO_SetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(120); /* RX line, drive low for 120us */ - pios_spektrum_cfg.port->BRR = pios_spektrum_cfg.pin; + GPIO_ResetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(120); /* RX line, drive high for 120us */ - pios_spektrum_cfg.port->BSRR = pios_spektrum_cfg.pin; + GPIO_SetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(120); /* RX line, drive low for 120us */ - pios_spektrum_cfg.port->BRR = pios_spektrum_cfg.pin; + GPIO_ResetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(120); /* RX line, drive high for 120us */ - pios_spektrum_cfg.port->BSRR = pios_spektrum_cfg.pin; + GPIO_SetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(120); /* RX line, drive low for 120us */ - pios_spektrum_cfg.port->BRR = pios_spektrum_cfg.pin; + GPIO_ResetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(120); /* RX line, drive high for 120us */ - pios_spektrum_cfg.port->BSRR = pios_spektrum_cfg.pin; + GPIO_SetBits(cfg->bind.gpio, cfg->bind.init.GPIO_Pin); PIOS_DELAY_WaituS(120); /* RX line, set input and wait for data, PIOS_SPEKTRUM_Init */ - return 1; + return true; } /** @@ -150,7 +142,7 @@ uint8_t PIOS_SPEKTRUM_Bind(void) * \return -2 if buffer full (retry) * \note Applications shouldn't call these functions directly */ -int32_t PIOS_SPEKTRUM_Decode(uint8_t b) +static int32_t PIOS_SPEKTRUM_Decode(uint8_t b) { static uint16_t channel = 0; /*, sync_word = 0;*/ uint8_t channeln = 0, frame = 0; @@ -226,11 +218,16 @@ int32_t PIOS_SPEKTRUM_Decode(uint8_t b) return 0; } -/* Interrupt handler for USART */ +/* Custom interrupt handler for USART */ void PIOS_SPEKTRUM_irq_handler(uint32_t usart_id) { + /* Grab the config for this device from the underlying USART device */ + const struct pios_usart_cfg * cfg; + cfg = PIOS_USART_GetConfig(usart_id); + PIOS_Assert(cfg); + /* by always reading DR after SR make sure to clear any error interrupts */ - volatile uint16_t sr = pios_spektrum_cfg.pios_usart_spektrum_cfg->regs->SR; - volatile uint8_t b = pios_spektrum_cfg.pios_usart_spektrum_cfg->regs->DR; + volatile uint16_t sr = cfg->regs->SR; + volatile uint8_t b = cfg->regs->DR; /* check if RXNE flag is set */ if (sr & USART_SR_RXNE) { @@ -241,7 +238,7 @@ void PIOS_SPEKTRUM_irq_handler(uint32_t usart_id) { if (sr & USART_SR_TXE) { // check if TXE flag is set /* Disable TXE interrupt (TXEIE=0) */ - USART_ITConfig(pios_spektrum_cfg.pios_usart_spektrum_cfg->regs, USART_IT_TXE, DISABLE); + USART_ITConfig(cfg->regs, USART_IT_TXE, DISABLE); } /* byte arrived so clear "watchdog" timer */ supv_timer=0; diff --git a/flight/PiOS/STM32F10x/pios_usart.c b/flight/PiOS/STM32F10x/pios_usart.c index 36b1b0c7a..1c087738c 100644 --- a/flight/PiOS/STM32F10x/pios_usart.c +++ b/flight/PiOS/STM32F10x/pios_usart.c @@ -51,6 +51,23 @@ const struct pios_com_driver pios_usart_com_driver = { .rx_avail = PIOS_USART_RxBufferUsed, }; +enum pios_usart_dev_magic { + PIOS_USART_DEV_MAGIC = 0x11223344, +}; + +struct pios_usart_dev { + enum pios_usart_dev_magic magic; + const struct pios_usart_cfg * cfg; + + // align to 32-bit to try and provide speed improvement; + uint8_t rx_buffer[PIOS_USART_RX_BUFFER_SIZE] __attribute__ ((aligned(4))); + t_fifo_buffer rx; + + // align to 32-bit to try and provide speed improvement; + uint8_t tx_buffer[PIOS_USART_TX_BUFFER_SIZE] __attribute__ ((aligned(4))); + t_fifo_buffer tx; +}; + static bool PIOS_USART_validate(struct pios_usart_dev * usart_dev) { return (usart_dev->magic == PIOS_USART_DEV_MAGIC); @@ -85,6 +102,34 @@ static struct pios_usart_dev * PIOS_USART_alloc(void) } #endif +/* Bind Interrupt Handlers + * + * Map all valid USART IRQs to the common interrupt handler + * and provide storage for a 32-bit device id IRQ to map + * each physical IRQ to a specific registered device instance. + */ +static void PIOS_USART_generic_irq_handler(uint32_t usart_id); + +static uint32_t PIOS_USART_1_id; +void USART1_IRQHandler(void) __attribute__ ((alias ("PIOS_USART_1_irq_handler"))); +static void PIOS_USART_1_irq_handler (void) +{ + PIOS_USART_generic_irq_handler (PIOS_USART_1_id); +} + +static uint32_t PIOS_USART_2_id; +void USART2_IRQHandler(void) __attribute__ ((alias ("PIOS_USART_2_irq_handler"))); +static void PIOS_USART_2_irq_handler (void) +{ + PIOS_USART_generic_irq_handler (PIOS_USART_2_id); +} + +static uint32_t PIOS_USART_3_id; +void USART3_IRQHandler(void) __attribute__ ((alias ("PIOS_USART_3_irq_handler"))); +static void PIOS_USART_3_irq_handler (void) +{ + PIOS_USART_generic_irq_handler (PIOS_USART_3_id); +} /** * Initialise a single USART device @@ -134,6 +179,11 @@ int32_t PIOS_USART_Init(uint32_t * usart_id, const struct pios_usart_cfg * cfg) *usart_id = (uint32_t)usart_dev; /* Configure USART Interrupts */ + switch ((uint32_t)usart_dev->cfg->regs) { + case (uint32_t)USART1: PIOS_USART_1_id = (uint32_t)usart_dev; + case (uint32_t)USART2: PIOS_USART_2_id = (uint32_t)usart_dev; + case (uint32_t)USART3: PIOS_USART_3_id = (uint32_t)usart_dev; + } NVIC_Init(&usart_dev->cfg->irq.init); USART_ITConfig(usart_dev->cfg->regs, USART_IT_RXNE, ENABLE); USART_ITConfig(usart_dev->cfg->regs, USART_IT_TXE, ENABLE); @@ -147,6 +197,19 @@ out_fail: return(-1); } +const struct pios_usart_cfg * PIOS_USART_GetConfig(uint32_t usart_id) +{ + struct pios_usart_dev * usart_dev = (struct pios_usart_dev *)usart_id; + + bool valid = PIOS_USART_validate(usart_dev); + + if (!valid) { + return (NULL); + } + + return usart_dev->cfg; +} + /** * Changes the baud rate of the USART peripheral without re-initialising. * \param[in] usart_id USART name (GPS, TELEM, AUX) @@ -157,7 +220,7 @@ static void PIOS_USART_ChangeBaud(uint32_t usart_id, uint32_t baud) struct pios_usart_dev * usart_dev = (struct pios_usart_dev *)usart_id; bool valid = PIOS_USART_validate(usart_dev); - PIOS_Assert(valid) + PIOS_Assert(valid); USART_InitTypeDef USART_InitStructure; @@ -337,12 +400,20 @@ static int32_t PIOS_USART_TxBufferPutMore(uint32_t usart_id, const uint8_t *buff return rc; } -void PIOS_USART_IRQ_Handler(uint32_t usart_id) +static void PIOS_USART_generic_irq_handler(uint32_t usart_id) { struct pios_usart_dev * usart_dev = (struct pios_usart_dev *)usart_id; bool valid = PIOS_USART_validate(usart_dev); - PIOS_Assert(valid) + PIOS_Assert(valid); + + /* Call any user provided callback function instead of processing + * the interrupt ourselves. + */ + if (usart_dev->cfg->irq.handler) { + (usart_dev->cfg->irq.handler)(usart_id); + return; + } /* Force read of dr after sr to make sure to clear error flags */ volatile uint16_t sr = usart_dev->cfg->regs->SR; diff --git a/flight/PiOS/inc/pios_sbus_priv.h b/flight/PiOS/inc/pios_sbus_priv.h index a0a97a860..7b880a2c8 100644 --- a/flight/PiOS/inc/pios_sbus_priv.h +++ b/flight/PiOS/inc/pios_sbus_priv.h @@ -66,25 +66,20 @@ #define SBUS_NUMBER_OF_CHANNELS 8 /* - * S.Bus configuration includes USART and programmable invertor + * S.Bus configuration programmable invertor */ struct pios_sbus_cfg { - const struct pios_usart_cfg *pios_usart_sbus_cfg; + struct stm32_gpio inv; void (*gpio_clk_func)(uint32_t periph, FunctionalState state); uint32_t gpio_clk_periph; - GPIO_TypeDef* gpio_inv_port; - GPIO_InitTypeDef gpio_inv_init; BitAction gpio_inv_enable; }; extern void PIOS_SBUS_irq_handler(); -extern uint8_t pios_sbus_num_channels; -extern const struct pios_sbus_cfg pios_sbus_cfg; - extern const struct pios_rcvr_driver pios_sbus_rcvr_driver; -extern void PIOS_SBUS_Init(void); +extern void PIOS_SBUS_Init(const struct pios_sbus_cfg * cfg); #endif /* PIOS_SBUS_PRIV_H */ diff --git a/flight/PiOS/inc/pios_spektrum.h b/flight/PiOS/inc/pios_spektrum.h index 40a995cd1..765d2c8a5 100644 --- a/flight/PiOS/inc/pios_spektrum.h +++ b/flight/PiOS/inc/pios_spektrum.h @@ -34,8 +34,6 @@ /* Global Types */ /* Public Functions */ -extern uint8_t PIOS_SPEKTRUM_Bind(void); -extern int32_t PIOS_SPEKTRUM_Decode(uint8_t b); #endif /* PIOS_SPEKTRUM_H */ diff --git a/flight/PiOS/inc/pios_spektrum_priv.h b/flight/PiOS/inc/pios_spektrum_priv.h index b300cb212..083df8fd3 100644 --- a/flight/PiOS/inc/pios_spektrum_priv.h +++ b/flight/PiOS/inc/pios_spektrum_priv.h @@ -36,21 +36,15 @@ #include struct pios_spektrum_cfg { - const struct pios_usart_cfg * pios_usart_spektrum_cfg; - GPIO_InitTypeDef gpio_init; + struct stm32_gpio bind; uint32_t remap; /* GPIO_Remap_* */ - GPIO_TypeDef * port; - uint16_t pin; }; extern void PIOS_SPEKTRUM_irq_handler(); -extern uint8_t pios_spektrum_num_channels; -extern const struct pios_spektrum_cfg pios_spektrum_cfg; - extern const struct pios_rcvr_driver pios_spektrum_rcvr_driver; -extern void PIOS_SPEKTRUM_Init(void); +extern void PIOS_SPEKTRUM_Init(const struct pios_spektrum_cfg * cfg, bool bind); #endif /* PIOS_PWM_PRIV_H */ diff --git a/flight/PiOS/inc/pios_stm32.h b/flight/PiOS/inc/pios_stm32.h index 1433d460b..3ea6e1f95 100644 --- a/flight/PiOS/inc/pios_stm32.h +++ b/flight/PiOS/inc/pios_stm32.h @@ -32,7 +32,7 @@ #define PIOS_STM32_H struct stm32_irq { - void (*handler) (void); + void (*handler) (uint32_t); uint32_t flags; NVIC_InitTypeDef init; }; diff --git a/flight/PiOS/inc/pios_usart_priv.h b/flight/PiOS/inc/pios_usart_priv.h index 772e6f4d2..edca829aa 100644 --- a/flight/PiOS/inc/pios_usart_priv.h +++ b/flight/PiOS/inc/pios_usart_priv.h @@ -48,26 +48,8 @@ struct pios_usart_cfg { struct stm32_irq irq; }; -enum pios_usart_dev_magic { - PIOS_USART_DEV_MAGIC = 0x11223344, -}; - -struct pios_usart_dev { - enum pios_usart_dev_magic magic; - const struct pios_usart_cfg * cfg; - - // align to 32-bit to try and provide speed improvement; - uint8_t rx_buffer[PIOS_USART_RX_BUFFER_SIZE] __attribute__ ((aligned(4))); - t_fifo_buffer rx; - - // align to 32-bit to try and provide speed improvement; - uint8_t tx_buffer[PIOS_USART_TX_BUFFER_SIZE] __attribute__ ((aligned(4))); - t_fifo_buffer tx; -}; - extern int32_t PIOS_USART_Init(uint32_t * usart_id, const struct pios_usart_cfg * cfg); - -extern void PIOS_USART_IRQ_Handler(uint32_t usart_id); +extern const struct pios_usart_cfg * PIOS_USART_GetConfig(uint32_t usart_id); #endif /* PIOS_USART_PRIV_H */ diff --git a/flight/PipXtreme/pios_board.c b/flight/PipXtreme/pios_board.c index a0b85915a..5bbca2f9f 100644 --- a/flight/PipXtreme/pios_board.c +++ b/flight/PipXtreme/pios_board.c @@ -90,7 +90,7 @@ static const struct pios_spi_cfg pios_spi_port_cfg = .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_SPI_port_irq_handler, + .handler = NULL, .flags = (DMA1_FLAG_TC2 | DMA1_FLAG_TE2 | DMA1_FLAG_HT2 | DMA1_FLAG_GL2), .init = { .NVIC_IRQChannel = DMA1_Channel2_IRQn, @@ -189,11 +189,11 @@ void PIOS_SPI_port_irq_handler(void) extern void PIOS_ADC_handler(void); void DMA1_Channel1_IRQHandler() __attribute__ ((alias("PIOS_ADC_handler"))); // Remap the ADC DMA handler to this one -const struct pios_adc_cfg pios_adc_cfg = { +static const struct pios_adc_cfg pios_adc_cfg = { .dma = { .ahb_clk = RCC_AHBPeriph_DMA1, .irq = { - .handler = PIOS_ADC_DMA_Handler, + .handler = NULL, .flags = (DMA1_FLAG_TC1 | DMA1_FLAG_TE1 | DMA1_FLAG_HT1 | DMA1_FLAG_GL1), .init = { .NVIC_IRQChannel = DMA1_Channel1_IRQn, @@ -245,10 +245,7 @@ void PIOS_ADC_handler() { /* * SERIAL USART */ -void PIOS_USART_serial_irq_handler(void); -void USART1_IRQHandler() __attribute__ ((alias ("PIOS_USART_serial_irq_handler"))); - -const struct pios_usart_cfg pios_usart_serial_cfg = +static const struct pios_usart_cfg pios_usart_serial_cfg = { .regs = USART1, .init = @@ -262,7 +259,7 @@ const struct pios_usart_cfg pios_usart_serial_cfg = }, .irq = { - .handler = PIOS_USART_serial_irq_handler, + .handler = NULL, .init = { .NVIC_IRQChannel = USART1_IRQn, @@ -293,12 +290,6 @@ const struct pios_usart_cfg pios_usart_serial_cfg = }, }; -static uint32_t pios_usart_serial_id; -void PIOS_USART_serial_irq_handler(void) -{ - PIOS_USART_IRQ_Handler(pios_usart_serial_id); -} - #endif /* PIOS_INCLUDE_USART */ // *********************************************************************************** @@ -334,6 +325,7 @@ void PIOS_Board_Init(void) { // Delay system PIOS_DELAY_Init(); + uint32_t pios_usart_serial_id; if (PIOS_USART_Init(&pios_usart_serial_id, &pios_usart_serial_cfg)) { PIOS_DEBUG_Assert(0); }