piotr/edgetx-gx12
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

chore(hal): remove StdPeriph (#5023)

Browse Source 
Co-authored-by: raphaelcoeffic <1050031+raphaelcoeffic@users.noreply.github.com>
Co-authored-by: Malte Langermann <malte@langermann.net>
Co-authored-by: 3djc <3djc@gh.com>
Co-authored-by: Richard Li <richard.li@ces.hk>
This commit is contained in:
Raphael Coeffic
2024-06-01 11:45:40 +10:00
committed by GitHub
co-authored by raphaelcoeffic Malte Langermann 3djc Richard Li
parent fea402a6e3
commit 6579905088
247 changed files with 2190 additions and 145252 deletions
Download Patch File Download Diff File Expand all files Collapse all files
radio/src/boards/generic_stm32/analog_inputs.cpp
+6 -5
View File
@@ -89,13 +89,14 @@ const etx_hal_adc_driver_t _adc_driver = {
};
#if defined(PWM_STICKS)
#include "stm32_gpio.h"
static const stick_pwm_timer_t _sticks_timer = {
PWM_GPIO,
PWM_GPIOA_PINS,
PWM_GPIO_AF,
PWM_TIMER,
PWM_IRQn,
.GPIOx = PWM_GPIO,
.GPIO_Pin = PWM_GPIOA_PINS,
.GPIO_Alternate = PWM_GPIO_AF,
.TIMx = PWM_TIMER,
.TIM_IRQn = PWM_IRQn,
};
#if !defined(PWM_IRQHandler)
radio/src/boards/generic_stm32/aux_ports.cpp
+20 -29
View File
@@ -20,8 +20,11 @@
*/
#include "hal/serial_port.h"
#include "hal/gpio.h"
#include "stm32_serial_driver.h"
#include "stm32_gpio_driver.h"
#include "stm32_gpio.h"
#include "board.h"
#include "dataconstants.h"
@@ -34,21 +37,10 @@
#endif
#if defined(AUX_SERIAL_PWR_GPIO) || defined(AUX2_SERIAL_PWR_GPIO)
static void _aux_pwr(GPIO_TypeDef *GPIOx, uint32_t pin, uint8_t on)
static void _aux_pwr(gpio_t pin, uint8_t on)
{
stm32_gpio_enable_clock(GPIOx);
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = pin;
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
pinInit.Pull = LL_GPIO_PULL_UP;
LL_GPIO_Init(GPIOx, &pinInit);
if (on) {
LL_GPIO_SetOutputPin(GPIOx, pin);
} else {
LL_GPIO_ResetOutputPin(GPIOx, pin);
}
gpio_init(pin, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_write(pin, on);
}
#endif
@@ -56,23 +48,22 @@ static void _aux_pwr(GPIO_TypeDef *GPIOx, uint32_t pin, uint8_t on)
#if !defined(AUX_SERIAL_DMA_TX)
#define AUX_SERIAL_DMA_TX nullptr
#define AUX_SERIAL_DMA_Stream_TX nullptr
#define AUX_SERIAL_DMA_Stream_TX_LL 0
#define AUX_SERIAL_DMA_Channel_TX 0
#define AUX_SERIAL_DMA_TX_STREAM 0
#define AUX_SERIAL_DMA_TX_CHANNEL 0
#endif
static const stm32_usart_t auxUSART = {
.USARTx = AUX_SERIAL_USART,
.GPIOx = AUX_SERIAL_GPIO,
.GPIO_Pin = AUX_SERIAL_GPIO_PIN_TX | AUX_SERIAL_GPIO_PIN_RX,
.txGPIO = AUX_SERIAL_TX_GPIO,
.rxGPIO = AUX_SERIAL_RX_GPIO,
.IRQn = AUX_SERIAL_USART_IRQn,
.IRQ_Prio = 7, // TODO: define constant
.txDMA = AUX_SERIAL_DMA_TX,
.txDMA_Stream = AUX_SERIAL_DMA_Stream_TX_LL,
.txDMA_Channel = AUX_SERIAL_DMA_Channel_TX,
.txDMA_Stream = AUX_SERIAL_DMA_TX_STREAM,
.txDMA_Channel = AUX_SERIAL_DMA_TX_CHANNEL,
.rxDMA = AUX_SERIAL_DMA_RX,
.rxDMA_Stream = AUX_SERIAL_DMA_Stream_RX_LL,
.rxDMA_Channel = AUX_SERIAL_DMA_Channel_RX,
.rxDMA_Stream = AUX_SERIAL_DMA_RX_STREAM,
.rxDMA_Channel = AUX_SERIAL_DMA_RX_CHANNEL,
};
DEFINE_STM32_SERIAL_PORT(Aux, auxUSART, AUX_SERIAL_RX_BUFFER, AUX_SERIAL_TX_BUFFER);
@@ -80,7 +71,7 @@ DEFINE_STM32_SERIAL_PORT(Aux, auxUSART, AUX_SERIAL_RX_BUFFER, AUX_SERIAL_TX_BUFF
#if defined(AUX_SERIAL_PWR_GPIO)
void set_aux_pwr(uint8_t on)
{
_aux_pwr(AUX_SERIAL_PWR_GPIO, AUX_SERIAL_PWR_GPIO_PIN, on);
_aux_pwr(AUX_SERIAL_PWR_GPIO, on);
}
#define AUX_PWR_FCT set_aux_pwr
#else
@@ -102,16 +93,16 @@ const etx_serial_port_t auxSerialPort = {
static const stm32_usart_t aux2USART = {
.USARTx = AUX2_SERIAL_USART,
.GPIOx = AUX2_SERIAL_GPIO,
.GPIO_Pin = AUX2_SERIAL_GPIO_PIN_TX | AUX2_SERIAL_GPIO_PIN_RX,
.txGPIO = AUX2_SERIAL_TX_GPIO,
.rxGPIO = AUX2_SERIAL_RX_GPIO,
.IRQn = AUX2_SERIAL_USART_IRQn,
.IRQ_Prio = 7, // TODO: define constant
.txDMA = nullptr,
.txDMA_Stream = 0,
.txDMA_Channel = 0,
.rxDMA = AUX2_SERIAL_DMA_RX,
.rxDMA_Stream = AUX2_SERIAL_DMA_Stream_RX_LL,
.rxDMA_Channel = AUX2_SERIAL_DMA_Channel_RX,
.rxDMA_Stream = AUX2_SERIAL_DMA_RX_STREAM,
.rxDMA_Channel = AUX2_SERIAL_DMA_RX_CHANNEL,
};
DEFINE_STM32_SERIAL_PORT(Aux2, aux2USART, AUX_SERIAL_RX_BUFFER, AUX_SERIAL_TX_BUFFER);
@@ -119,7 +110,7 @@ DEFINE_STM32_SERIAL_PORT(Aux2, aux2USART, AUX_SERIAL_RX_BUFFER, AUX_SERIAL_TX_BU
#if defined(AUX2_SERIAL_PWR_GPIO)
void set_aux2_pwr(uint8_t on)
{
_aux_pwr(AUX2_SERIAL_PWR_GPIO, AUX2_SERIAL_PWR_GPIO_PIN, on);
_aux_pwr(AUX2_SERIAL_PWR_GPIO, on);
}
#define AUX2_PWR_FCT set_aux2_pwr
#else
radio/src/boards/generic_stm32/bor_level.cpp
+23 -6
View File
@@ -20,16 +20,33 @@
*/
#if defined(STM32F4)
#include "stm32f4xx_flash.h"
#include "stm32_hal.h"
void board_set_bor_level()
{
if (FLASH_OB_GetBOR() != OB_BOR_LEVEL3)
FLASH_OBProgramInitTypeDef OB;
HAL_FLASHEx_OBGetConfig(&OB);
if (OB.BORLevel != OB_BOR_LEVEL3)
{
FLASH_OB_Unlock();
FLASH_OB_BORConfig(OB_BOR_LEVEL3);
FLASH_OB_Launch();
FLASH_OB_Lock();
HAL_FLASH_Unlock();
HAL_FLASH_OB_Unlock();
OB.OptionType = OPTIONBYTE_BOR;
OB.BORLevel = OB_BOR_LEVEL3;
if ( HAL_FLASHEx_OBProgram(&OB) != HAL_OK )
{
HAL_FLASH_OB_Lock();
HAL_FLASH_Lock();
}
HAL_FLASH_OB_Launch();
HAL_FLASH_OB_Lock();
HAL_FLASH_Lock();
}
}
#endif
radio/src/boards/generic_stm32/module_ports.cpp
+49 -98
View File
@@ -19,7 +19,10 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "hal/module_port.h"
#include "stm32_gpio.h"
#include "stm32_serial_driver.h"
#include "stm32_softserial_driver.h"
#include "stm32_dma.h"
@@ -36,8 +39,8 @@
static const stm32_usart_t intmoduleUSART = {
.USARTx = INTMODULE_USART,
.GPIOx = INTMODULE_GPIO,
.GPIO_Pin = INTMODULE_TX_GPIO_PIN | INTMODULE_RX_GPIO_PIN,
.txGPIO = INTMODULE_TX_GPIO,
.rxGPIO = INTMODULE_RX_GPIO,
.IRQn = INTMODULE_USART_IRQn,
.IRQ_Prio = INTMODULE_USART_IRQ_PRIORITY,
#if defined(INTMODULE_DMA)
@@ -70,8 +73,7 @@ DEFINE_STM32_SERIAL_PORT(InternalModule, intmoduleUSART, INTMODULE_FIFO_SIZE, 0)
static stm32_pulse_dma_tc_cb_t _int_timer_DMA_TC_Callback;
static const stm32_pulse_timer_t intmoduleTimer = {
.GPIOx = INTMODULE_TX_GPIO,
.GPIO_Pin = INTMODULE_TX_GPIO_PIN,
.GPIO = INTMODULE_TX_GPIO,
.GPIO_Alternate = INTMODULE_TX_GPIO_AF,
.TIMx = INTMODULE_TIMER,
.TIM_Freq = INTMODULE_TIMER_FREQ,
@@ -123,34 +125,21 @@ DEFINE_STM32_SOFTSERIAL_PORT(InternalModule, intmoduleTimer);
#define EXTMODULE_USART_IRQ_PRIORITY 6
#if defined(EXTMODULE_TX_INVERT_GPIO) && defined(EXTMODULE_RX_INVERT_GPIO)
#define HAS_EXTMODULE_INVERTERS
static void _extmod_set_inverted(uint8_t enable)
{
// In EdgeTX the external module is normally always
// inverted, so invert the logic here
if (!enable) {
LL_GPIO_SetOutputPin(EXTMODULE_TX_INVERT_GPIO,
EXTMODULE_TX_INVERT_GPIO_PIN);
LL_GPIO_SetOutputPin(EXTMODULE_RX_INVERT_GPIO,
EXTMODULE_RX_INVERT_GPIO_PIN);
} else {
LL_GPIO_ResetOutputPin(EXTMODULE_TX_INVERT_GPIO,
EXTMODULE_TX_INVERT_GPIO_PIN);
LL_GPIO_ResetOutputPin(EXTMODULE_RX_INVERT_GPIO,
EXTMODULE_RX_INVERT_GPIO_PIN);
}
gpio_write(EXTMODULE_TX_INVERT_GPIO, !enable);
gpio_write(EXTMODULE_RX_INVERT_GPIO, !enable);
}
static void _extmod_init_inverter()
{
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
pinInit.Pin = EXTMODULE_TX_INVERT_GPIO_PIN;
LL_GPIO_Init(EXTMODULE_TX_INVERT_GPIO, &pinInit);
pinInit.Pin = EXTMODULE_RX_INVERT_GPIO_PIN;
LL_GPIO_Init(EXTMODULE_RX_INVERT_GPIO, &pinInit);
gpio_init(EXTMODULE_TX_INVERT_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(EXTMODULE_RX_INVERT_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
// this sets the output to idle-low as is
// the default in EdgeTX on external module
@@ -161,15 +150,15 @@ static void _extmod_init_inverter()
static const stm32_usart_t extmoduleUSART = {
.USARTx = EXTMODULE_USART,
.GPIOx = EXTMODULE_TX_GPIO,
.GPIO_Pin = EXTMODULE_TX_GPIO_PIN | EXTMODULE_RX_GPIO_PIN,
.txGPIO = EXTMODULE_TX_GPIO,
.rxGPIO = EXTMODULE_RX_GPIO,
.IRQn = EXTMODULE_USART_IRQn,
.IRQ_Prio = EXTMODULE_USART_IRQ_PRIORITY,
.txDMA = EXTMODULE_USART_TX_DMA,
.txDMA_Stream = EXTMODULE_USART_TX_DMA_STREAM_LL,
.txDMA_Stream = EXTMODULE_USART_TX_DMA_STREAM,
.txDMA_Channel = EXTMODULE_USART_TX_DMA_CHANNEL,
.rxDMA = EXTMODULE_USART_TX_DMA,
.rxDMA_Stream = EXTMODULE_USART_RX_DMA_STREAM_LL,
.rxDMA_Stream = EXTMODULE_USART_RX_DMA_STREAM,
.rxDMA_Channel = EXTMODULE_USART_RX_DMA_CHANNEL,
.set_input = nullptr,
.txDMA_IRQn = (IRQn_Type)0,
@@ -182,8 +171,7 @@ DEFINE_STM32_SERIAL_PORT(ExternalModule, extmoduleUSART, INTMODULE_FIFO_SIZE, 0)
static const stm32_usart_t sbus_trainer_USART = {
.USARTx = TRAINER_MODULE_SBUS_USART,
.GPIOx = TRAINER_MODULE_SBUS_GPIO,
.GPIO_Pin = TRAINER_MODULE_SBUS_GPIO_PIN,
.rxGPIO = TRAINER_MODULE_SBUS_GPIO,
.IRQn = (IRQn_Type)-1,
.IRQ_Prio = 0,
.txDMA = nullptr,
@@ -201,15 +189,14 @@ DEFINE_STM32_SERIAL_PORT(SbusTrainer, sbus_trainer_USART, 32, 0);
static stm32_pulse_dma_tc_cb_t _ext_timer_DMA_TC_Callback;
static const stm32_pulse_timer_t extmoduleTimer = {
.GPIOx = EXTMODULE_TX_GPIO,
.GPIO_Pin = EXTMODULE_TX_GPIO_PIN,
.GPIO = EXTMODULE_TX_GPIO,
.GPIO_Alternate = EXTMODULE_TIMER_TX_GPIO_AF,
.TIMx = EXTMODULE_TIMER,
.TIM_Freq = EXTMODULE_TIMER_FREQ,
.TIM_Channel = EXTMODULE_TIMER_Channel,
.TIM_IRQn = EXTMODULE_TIMER_IRQn,
.DMAx = EXTMODULE_TIMER_DMA,
.DMA_Stream = EXTMODULE_TIMER_DMA_STREAM_LL,
.DMA_Stream = EXTMODULE_TIMER_DMA_STREAM,
.DMA_Channel = EXTMODULE_TIMER_DMA_CHANNEL,
.DMA_IRQn = EXTMODULE_TIMER_DMA_STREAM_IRQn,
.DMA_TC_CallbackPtr = &_ext_timer_DMA_TC_Callback,
@@ -220,7 +207,7 @@ static_assert(__STM32_PULSE_IS_TIMER_CHANNEL_SUPPORTED(EXTMODULE_TIMER_Channel),
"Unsupported timer channel");
// Make sure the DMA channel is supported
static_assert(__STM32_DMA_IS_STREAM_SUPPORTED(EXTMODULE_TIMER_DMA_STREAM_LL),
static_assert(__STM32_DMA_IS_STREAM_SUPPORTED(EXTMODULE_TIMER_DMA_STREAM),
"Unsupported DMA stream");
#if !defined(EXTMODULE_TIMER_DMA_IRQHandler)
@@ -249,8 +236,7 @@ static_assert(__IS_TRAINER_TIMER_IN_CHANNEL_SUPPORTED(TRAINER_MODULE_CPPM_TIMER_
"Unsupported trainer timer input channel");
static const stm32_pulse_timer_t trainerModuleTimer = {
.GPIOx = TRAINER_MODULE_CPPM_GPIO,
.GPIO_Pin = TRAINER_MODULE_CPPM_GPIO_PIN,
.GPIO = TRAINER_MODULE_CPPM_GPIO,
.GPIO_Alternate = TRAINER_MODULE_CPPM_GPIO_AF,
.TIMx = TRAINER_MODULE_CPPM_TIMER,
.TIM_Freq = TRAINER_MODULE_CPPM_FREQ,
@@ -273,47 +259,34 @@ static const stm32_pulse_timer_t trainerModuleTimer = {
static void _set_sport_input(uint8_t enable)
{
if (TELEMETRY_SET_INPUT) {
if (enable) {
LL_GPIO_SetOutputPin(TELEMETRY_DIR_GPIO, TELEMETRY_DIR_GPIO_PIN);
} else {
LL_GPIO_ResetOutputPin(TELEMETRY_DIR_GPIO, TELEMETRY_DIR_GPIO_PIN);
}
gpio_write(TELEMETRY_DIR_GPIO, enable);
} else {
if (enable) {
LL_GPIO_ResetOutputPin(TELEMETRY_DIR_GPIO, TELEMETRY_DIR_GPIO_PIN);
} else {
LL_GPIO_SetOutputPin(TELEMETRY_DIR_GPIO, TELEMETRY_DIR_GPIO_PIN);
}
gpio_write(TELEMETRY_DIR_GPIO, !enable);
}
}
#if defined(TELEMETRY_REV_GPIO)
#if defined(TELEMETRY_TX_REV_GPIO) && defined(TELEMETRY_RX_REV_GPIO)
#define HAS_SPORT_INVERTER
static void _sport_set_inverted(uint8_t enable)
{
uint32_t pins = TELEMETRY_TX_REV_GPIO_PIN | TELEMETRY_RX_REV_GPIO_PIN;
if (!enable) {
LL_GPIO_SetOutputPin(TELEMETRY_REV_GPIO, pins);
} else {
LL_GPIO_ResetOutputPin(TELEMETRY_REV_GPIO, pins);
}
gpio_write(TELEMETRY_TX_REV_GPIO, !enable);
gpio_write(TELEMETRY_RX_REV_GPIO, !enable);
}
static void _sport_init_inverter()
{
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = TELEMETRY_TX_REV_GPIO_PIN | TELEMETRY_RX_REV_GPIO_PIN;
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
LL_GPIO_Init(TELEMETRY_REV_GPIO, &pinInit);
gpio_init(TELEMETRY_TX_REV_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(TELEMETRY_RX_REV_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
_sport_set_inverted(false);
}
#endif
static const stm32_usart_t sportUSART = {
.USARTx = TELEMETRY_USART,
.GPIOx = TELEMETRY_GPIO,
.GPIO_Pin = TELEMETRY_TX_GPIO_PIN | TELEMETRY_RX_GPIO_PIN,
.txGPIO = TELEMETRY_TX_GPIO,
.rxGPIO = TELEMETRY_RX_GPIO,
.IRQn = TELEMETRY_USART_IRQn,
.IRQ_Prio = TELEMETRY_USART_IRQ_PRIORITY,
.txDMA = TELEMETRY_DMA,
@@ -336,26 +309,19 @@ DEFINE_STM32_SERIAL_PORT(SportModule, sportUSART, TELEMETRY_FIFO_SIZE, 0);
static void _sport_direction_init()
{
LL_GPIO_InitTypeDef dirPinInit;
LL_GPIO_StructInit(&dirPinInit);
dirPinInit.Pin = TELEMETRY_DIR_GPIO_PIN;
dirPinInit.Mode = LL_GPIO_MODE_OUTPUT;
LL_GPIO_Init(TELEMETRY_DIR_GPIO, &dirPinInit);
gpio_init(TELEMETRY_DIR_GPIO, GPIO_OUT, GPIO_PIN_SPEED_MEDIUM);
}
#if defined(TELEMETRY_TIMER)
static const stm32_softserial_rx_port sportSoftRX = {
.GPIOx = TELEMETRY_GPIO,
.GPIO_Pin = TELEMETRY_RX_GPIO_PIN,
.GPIO = TELEMETRY_RX_GPIO,
.TIMx = TELEMETRY_TIMER,
.TIM_Freq = PERI2_FREQUENCY * TIMER_MULT_APB2,
.TIM_IRQn = TELEMETRY_TIMER_IRQn,
.EXTI_Port = TELEMETRY_EXTI_PORT,
.EXTI_SysLine = TELEMETRY_EXTI_SYS_LINE,
.EXTI_Line = TELEMETRY_EXTI_LINE,
.dir_GPIOx = TELEMETRY_DIR_GPIO,
.dir_Pin = TELEMETRY_DIR_GPIO_PIN,
.dir_GPIO = TELEMETRY_DIR_GPIO,
.dir_Input = TELEMETRY_SET_INPUT,
// re-use S.PORT serial RX buffer
.buffer = { SportModule_RXBuffer, TELEMETRY_FIFO_SIZE },
@@ -386,11 +352,7 @@ static void _internal_module_set_bootcmd(uint8_t enable)
enable = !enable;
}
if (enable) {
LL_GPIO_SetOutputPin(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_GPIO_PIN);
} else {
LL_GPIO_ResetOutputPin(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_GPIO_PIN);
}
gpio_write(INTMODULE_BOOTCMD_GPIO, enable);
}
#endif
@@ -443,14 +405,14 @@ static void _external_module_set_pwr(uint8_t enable)
EXTERNAL_MODULE_ON();
#if defined(PCBNV14)
if (hardwareOptions.pcbrev == PCBREV_NV14) {
LL_GPIO_ResetOutputPin(EXTMODULE_PWR_FIX_GPIO, EXTMODULE_PWR_FIX_GPIO_PIN);
gpio_clear(EXTMODULE_PWR_FIX_GPIO);
}
#endif
} else {
EXTERNAL_MODULE_OFF();
#if defined(PCBNV14)
if (hardwareOptions.pcbrev == PCBREV_NV14) {
LL_GPIO_SetOutputPin(EXTMODULE_PWR_FIX_GPIO, EXTMODULE_PWR_FIX_GPIO_PIN);
gpio_set(EXTMODULE_PWR_FIX_GPIO);
}
#endif
}
@@ -465,7 +427,7 @@ static const etx_module_port_t _external_ports[] = {
.dir_flags = ETX_MOD_DIR_TX_RX | ETX_MOD_FULL_DUPLEX,
.drv = { .serial = &STM32SerialDriver },
.hw_def = REF_STM32_SERIAL_PORT(ExternalModule),
#if defined(EXTMODULE_TX_INVERT_GPIO) && defined(EXTMODULE_RX_INVERT_GPIO)
#if defined(HAS_EXTMODULE_INVERTERS)
.set_inverted = _extmod_set_inverted,
#else
.set_inverted = nullptr,
@@ -479,7 +441,7 @@ static const etx_module_port_t _external_ports[] = {
.dir_flags = ETX_MOD_DIR_TX,
.drv = { .timer = &STM32ModuleTimerDriver },
.hw_def = (void*)&extmoduleTimer,
#if defined(EXTMODULE_TX_INVERT_GPIO) && defined(EXTMODULE_RX_INVERT_GPIO)
#if defined(HAS_EXTMODULE_INVERTERS)
.set_inverted = _extmod_set_inverted,
#else
.set_inverted = nullptr,
@@ -492,7 +454,7 @@ static const etx_module_port_t _external_ports[] = {
.dir_flags = ETX_MOD_DIR_TX,
.drv = { .serial = &STM32SoftSerialTxDriver },
.hw_def = REF_STM32_SOFTSERIAL_PORT(ExternalModule),
#if defined(EXTMODULE_TX_INVERT_GPIO) && defined(EXTMODULE_RX_INVERT_GPIO)
#if defined(HAS_EXTMODULE_INVERTERS)
.set_inverted = _extmod_set_inverted,
#else
.set_inverted = nullptr,
@@ -527,7 +489,7 @@ static const etx_module_port_t _external_ports[] = {
.dir_flags = ETX_MOD_DIR_TX | ETX_MOD_DIR_RX,
.drv = { .serial = &STM32SerialDriver },
.hw_def = REF_STM32_SERIAL_PORT(SportModule),
#if defined(TELEMETRY_REV_GPIO)
#if defined(HAS_SPORT_INVERTER)
.set_inverted = _sport_set_inverted,
#else
.set_inverted = nullptr,
@@ -560,11 +522,7 @@ static const etx_module_t _external_module = {
// from board.cpp
void _sport_set_pwr(uint8_t enabled)
{
if (enabled) {
LL_GPIO_SetOutputPin(SPORT_UPDATE_PWR_GPIO, SPORT_UPDATE_PWR_GPIO_PIN);
} else {
LL_GPIO_ResetOutputPin(SPORT_UPDATE_PWR_GPIO, SPORT_UPDATE_PWR_GPIO_PIN);
}
gpio_write(SPORT_UPDATE_PWR_GPIO, enabled);
}
#if defined(RADIO_X7)
@@ -598,26 +556,19 @@ void boardInitModulePorts()
sportUpdateInit();
#endif
#if defined(TELEMETRY_REV_GPIO)
#if defined(HAS_SPORT_INVERTER)
_sport_init_inverter();
#endif
#if defined(EXTMODULE_TX_INVERT_GPIO) && defined(EXTMODULE_RX_INVERT_GPIO)
#if defined(HAS_EXTMODULE_INVERTERS)
_extmod_init_inverter();
#endif
#if defined(PCBNV14)
if (hardwareOptions.pcbrev == PCBREV_NV14) {
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = EXTMODULE_PWR_FIX_GPIO_PIN;
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
// pin must be pulled to V+ (voltage of board - VCC is not enough to fully close transistor)
// for additional transistor to ensuring module is completely disabled
pinInit.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
LL_GPIO_SetOutputPin(EXTMODULE_PWR_FIX_GPIO, EXTMODULE_PWR_FIX_GPIO_PIN);
LL_GPIO_Init(EXTMODULE_PWR_FIX_GPIO, &pinInit);
gpio_init(EXTMODULE_PWR_FIX_GPIO, GPIO_OD, GPIO_PIN_SPEED_LOW);
gpio_set(EXTMODULE_PWR_FIX_GPIO);
}
#endif
}
radio/src/boards/generic_stm32/rgb_leds.cpp
+4 -3
View File
@@ -28,6 +28,8 @@
#include "stm32_ws2812.h"
#include "stm32_dma.h"
#include "stm32_gpio.h"
#include "hal/gpio.h"
#if !defined(SIMU)
#include <FreeRTOS/include/FreeRTOS.h>
@@ -81,9 +83,8 @@ void rgbLedStop()
}
const stm32_pulse_timer_t _led_timer = {
.GPIOx = LED_STRIP_GPIO,
.GPIO_Pin = LED_STRIP_GPIO_PIN_DATA,
.GPIO_Alternate = LED_STRIP_GPIO_PIN_AF,
.GPIO = LED_STRIP_GPIO,
.GPIO_Alternate = LED_STRIP_GPIO_AF,
.TIMx = LED_STRIP_TIMER,
.TIM_Freq = LED_STRIP_TIMER_FREQ,
.TIM_Channel = LED_STRIP_TIMER_CHANNEL,
radio/src/boards/generic_stm32/sport_update.cpp
+6 -8
View File
@@ -19,10 +19,14 @@
* GNU General Public License for more details.
*/
#include "hal.h"
#include "stm32_hal_ll.h"
#include "stm32_gpio.h"
#include "hal/module_port.h"
#include "hal/gpio.h"
#include "hal.h"
#include "opentx.h" // g_eeGeneral
void sportUpdateInit()
@@ -41,13 +45,7 @@ void sportUpdateInit()
}
#endif
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = SPORT_UPDATE_PWR_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(SPORT_UPDATE_PWR_GPIO, &GPIO_InitStructure);
gpio_init(SPORT_UPDATE_PWR_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
}
radio/src/boards/generic_stm32/trainer_ports.cpp
+10 -17
View File
@@ -21,8 +21,10 @@
#include "stm32_pulse_driver.h"
#include "stm32_gpio_driver.h"
#include "stm32_gpio.h"
#include "trainer_driver.h"
#include "hal/gpio.h"
#include "hal/module_port.h"
#include "dataconstants.h"
@@ -30,21 +32,14 @@
void board_trainer_init()
{
#if defined(TRAINER_DETECT_GPIO_PIN)
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = TRAINER_DETECT_GPIO_PIN;
pinInit.Mode = LL_GPIO_MODE_INPUT;
pinInit.Pull = LL_GPIO_PULL_UP;
stm32_gpio_enable_clock(TRAINER_DETECT_GPIO);
LL_GPIO_Init(TRAINER_DETECT_GPIO, &pinInit);
#if defined(TRAINER_DETECT_GPIO)
gpio_init(TRAINER_DETECT_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
#endif
trainer_init();
}
#if defined(TRAINER_GPIO)
#if defined(TRAINER_IN_GPIO)
bool trainer_dsc_available() { return true; }
@@ -55,8 +50,7 @@ static_assert(__IS_TRAINER_TIMER_IN_CHANNEL_SUPPORTED(TRAINER_IN_TIMER_Channel),
"Unsupported trainer timer input channel");
static const stm32_pulse_timer_t trainerOutputTimer = {
.GPIOx = TRAINER_GPIO,
.GPIO_Pin = TRAINER_OUT_GPIO_PIN,
.GPIO = TRAINER_OUT_GPIO,
.GPIO_Alternate = TRAINER_GPIO_AF,
.TIMx = TRAINER_TIMER,
.TIM_Freq = TRAINER_TIMER_FREQ,
@@ -75,8 +69,7 @@ void trainer_init_dsc_out()
}
static const stm32_pulse_timer_t trainerInputTimer = {
.GPIOx = TRAINER_GPIO,
.GPIO_Pin = TRAINER_IN_GPIO_PIN,
.GPIO = TRAINER_IN_GPIO,
.GPIO_Alternate = TRAINER_GPIO_AF,
.TIMx = TRAINER_TIMER,
.TIM_Freq = TRAINER_TIMER_FREQ,
@@ -105,14 +98,14 @@ void trainer_stop_dsc() {}
bool is_trainer_dsc_connected()
{
#if defined(TRAINER_DETECT_GPIO_PIN)
bool set = LL_GPIO_IsInputPinSet(TRAINER_DETECT_GPIO, TRAINER_DETECT_GPIO_PIN);
#if defined(TRAINER_DETECT_GPIO)
bool set = gpio_read(TRAINER_DETECT_GPIO);
#if defined(TRAINER_DETECT_INVERTED)
return !set;
#else
return set;
#endif
#else // TRAINER_DETECT_GPIO_PIN
#else // TRAINER_DETECT_GPIO
return true;
#endif
}
radio/src/cli.cpp
+10 -10
View File
@@ -998,24 +998,24 @@ int cliSet(const char **argv)
}
cliSerialPrint("%s: rfmod %d power %s", argv[0], module, argv[4]);
}
#if defined(INTMODULE_BOOTCMD_GPIO)
else if (!strcmp(argv[3], "bootpin")) {
int level = 0;
if (toInt(argv, 4, &level) < 0) {
cliSerialPrint("%s: invalid bootpin argument '%s'", argv[0], argv[4]);
return -1;
}
if (module == 0) {
if (level) {
GPIO_SetBits(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_GPIO_PIN);
cliSerialPrint("%s: bootpin set", argv[0]);
} else {
GPIO_ResetBits(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_GPIO_PIN);
cliSerialPrint("%s: bootpin reset", argv[0]);
}
const auto* mod = modulePortGetModuleDescription(INTERNAL_MODULE);
if (!mod || !mod->set_bootcmd) {
cliSerialPrint("%s: invalid module or has no bootcmd pin", argv[0]);
return -1;
}
mod->set_bootcmd(level);
if (level) {
cliSerialPrint("%s: bootcmd set", argv[0]);
} else {
cliSerialPrint("%s: bootcmd reset", argv[0]);
}
}
#endif
else {
if (strlen(argv[2]) == 0) {
cliSerialPrint("%s: missing rfmod arguments", argv[0]);
radio/src/hal/gpio.h
+52
View File
@@ -0,0 +1,52 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#include <stdint.h>
typedef uint32_t gpio_t;
typedef uint8_t gpio_mode_t;
typedef uint8_t gpio_af_t;
typedef uint8_t gpio_speed_t;
typedef enum {
GPIO_RISING = 1,
GPIO_FALLING = 2,
GPIO_BOTH = 3
} gpio_flank_t;
typedef void (*gpio_cb_t)();
void gpio_init(gpio_t pin, gpio_mode_t mode, gpio_speed_t speed);
void gpio_init_af(gpio_t pin, gpio_af_t af, gpio_speed_t speed);
void gpio_init_int(gpio_t pin, gpio_mode_t mode, gpio_flank_t flank, gpio_cb_t cb);
void gpio_init_analog(gpio_t pin);
void gpio_int_disable(gpio_t pin);
gpio_mode_t gpio_get_mode(gpio_t pin);
int gpio_read(gpio_t pin);
void gpio_set(gpio_t pin);
void gpio_clear(gpio_t pin);
void gpio_write(gpio_t pin, int value);
void gpio_toggle(gpio_t pin);
radio/src/lv_conf.h
+15 -15
View File
@@ -173,21 +173,21 @@
/*Must be defined to include path of CMSIS header of target processor
e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
#define LV_GPU_DMA2D_CMSIS_INCLUDE "stm32f4xx.h"
#if !defined(DMA2D_NLR_PL_Pos)
#define DMA2D_NLR_PL_Pos 16
#endif
#if !defined(DMA2D_NLR_NL_Pos)
#define DMA2D_NLR_NL_Pos 0
#endif
#if !defined(DMA2D_CR_START_Msk)
#define DMA2D_CR_START_Msk DMA2D_CR_START
#endif
#if !defined(DMA2D_FGPFCCR_AM_Pos)
#define DMA2D_FGPFCCR_AM_Pos 16
#endif
#if !defined(DMA2D_FGPFCCR_ALPHA_Pos)
#define DMA2D_FGPFCCR_ALPHA_Pos 24
#endif
// #if !defined(DMA2D_NLR_PL_Pos)
// #define DMA2D_NLR_PL_Pos 16
// #endif
// #if !defined(DMA2D_NLR_NL_Pos)
// #define DMA2D_NLR_NL_Pos 0
// #endif
// #if !defined(DMA2D_CR_START_Msk)
// #define DMA2D_CR_START_Msk DMA2D_CR_START
// #endif
// #if !defined(DMA2D_FGPFCCR_AM_Pos)
// #define DMA2D_FGPFCCR_AM_Pos 16
// #endif
// #if !defined(DMA2D_FGPFCCR_ALPHA_Pos)
// #define DMA2D_FGPFCCR_ALPHA_Pos 24
// #endif
#endif
/*Use NXP's PXP GPU iMX RTxxx platforms*/
radio/src/main.cpp
+1 -24
View File
@@ -19,12 +19,11 @@
* GNU General Public License for more details.
*/
#include "opentx.h"
#include "hal/adc_driver.h"
#include "hal/storage.h"
#include "hal/abnormal_reboot.h"
#include "hal/usb_driver.h"
#include "opentx.h"
#if defined(LIBOPENUI)
#include "libopenui.h"
@@ -203,28 +202,6 @@ void handleUsbConnection()
#endif // defined(STM32) && !defined(SIMU)
}
#if defined(JACK_DETECT_GPIO) && !defined(SIMU)
bool isJackPlugged()
{
// debounce
static bool debounced_state = 0;
static bool last_state = 0;
if (GPIO_ReadInputDataBit(JACK_DETECT_GPIO, JACK_DETECT_GPIO_PIN)) {
if (!last_state) {
debounced_state = false;
}
last_state = false;
} else {
if (last_state) {
debounced_state = true;
}
last_state = true;
}
return debounced_state;
}
#endif
#if defined(PCBXLITES)
uint8_t jackState = SPEAKER_ACTIVE;
radio/src/opentx.cpp
+5 -3
View File
@@ -22,6 +22,8 @@
#if !defined(SIMU)
#include "stm32_ws2812.h"
#include "boards/generic_stm32/rgb_leds.h"
#include "stm32_hal.h"
#include "stm32_hal_ll.h"
#endif
#include "opentx.h"
@@ -104,9 +106,9 @@ void toggleLatencySwitch()
#if defined(PCBHORUS)
if (latencyToggleSwitch)
GPIO_ResetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
gpio_clear(EXTMODULE_TX_GPIO);
else
GPIO_SetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
gpio_set(EXTMODULE_TX_GPIO);
#else
if (latencyToggleSwitch)
sportUpdatePowerOn();
@@ -1561,7 +1563,7 @@ int main()
#if !defined(SIMU)
/* Ensure all priority bits are assigned as preemption priority bits. */
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
NVIC_SetPriorityGrouping( NVIC_PRIORITYGROUP_4 );
#endif
// G: The WDT remains active after a WDT reset -- at maximum clock speed. So it's
radio/src/targets/common/arm/stm32/CMakeLists.txt
+1
View File
@@ -91,6 +91,7 @@ if(NOT NATIVE_BUILD)
${STM32_DRIVER_DIR}/stm32_i2c_driver.cpp
${STM32_DRIVER_DIR}/stm32_timer.cpp
${STM32_DRIVER_DIR}/stm32_dma.cpp
${STM32_DRIVER_DIR}/stm32_gpio.cpp
${STM32_DRIVER_DIR}/stm32_spi.cpp
${STM32_DRIVER_DIR}/stm32_adc.cpp
)
radio/src/targets/common/arm/stm32/audio_dac_driver.cpp
+26 -39
View File
@@ -19,6 +19,11 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
#include "stm32_dma.h"
#include "opentx.h"
#if !defined(SIMU)
@@ -27,7 +32,6 @@ const AudioBuffer * nextBuffer = nullptr;
void setSampleRate(uint32_t frequency)
{
uint32_t timer = (PERI1_FREQUENCY * TIMER_MULT_APB1) / frequency - 1 ; // MCK/8 and 100 000 Hz
AUDIO_TIMER->CR1 &= ~TIM_CR1_CEN ;
AUDIO_TIMER->CNT = 0 ;
AUDIO_TIMER->ARR = limit<uint32_t>(2, timer, 65535) ;
@@ -37,38 +41,30 @@ void setSampleRate(uint32_t frequency)
// Start TIMER6 at 100000Hz, used for DAC trigger
void dacTimerInit()
{
AUDIO_TIMER->PSC = 0 ; // Max speed
stm32_timer_enable_clock(AUDIO_TIMER);
AUDIO_TIMER->PSC = 0 ; // Max speed
AUDIO_TIMER->ARR = (PERI1_FREQUENCY * TIMER_MULT_APB1) / 100000 - 1 ; // 10 uS, 100 kHz
AUDIO_TIMER->CR2 = 0 ;
AUDIO_TIMER->CR2 = 0x20 ;
AUDIO_TIMER->CR1 = TIM_CR1_CEN ;
}
#if defined(AUDIO_MUTE_GPIO_PIN)
#if defined(AUDIO_MUTE_GPIO)
static inline void setMutePin(bool enabled)
{
if (enabled) {
#if defined(INVERTED_MUTE_PIN)
GPIO_ResetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
#else
GPIO_SetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
enabled = !enabled;
#endif
} else {
#if defined(INVERTED_MUTE_PIN)
GPIO_SetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
#else
GPIO_ResetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
#endif
}
gpio_write(AUDIO_MUTE_GPIO, enabled);
}
static inline bool getMutePin(void)
{
bool enabled = gpio_read(AUDIO_MUTE_GPIO) ? 1 : 0;
#if defined(INVERTED_MUTE_PIN)
return !GPIO_ReadOutputDataBit(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
#else
return GPIO_ReadOutputDataBit(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
enabled = !enabled;
#endif
return enabled;
}
#endif
@@ -76,27 +72,17 @@ static inline bool getMutePin(void)
// Not sure why PB14 has not be allocated to the DAC, although it is an EXTRA function
// So maybe it is automatically done
void dacInit()
{
dacTimerInit();
GPIO_InitTypeDef GPIO_InitStructure;
#if defined(AUDIO_MUTE_GPIO_PIN)
GPIO_InitStructure.GPIO_Pin = AUDIO_MUTE_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(AUDIO_MUTE_GPIO, &GPIO_InitStructure);
{
#if defined(AUDIO_MUTE_GPIO)
// Mute before init anything
gpio_init(AUDIO_MUTE_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
setMutePin(true);
#endif
GPIO_InitStructure.GPIO_Pin = AUDIO_OUTPUT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(AUDIO_OUTPUT_GPIO, &GPIO_InitStructure);
dacTimerInit();
gpio_init_analog(AUDIO_OUTPUT_GPIO);
stm32_dma_enable_clock(AUDIO_DMA);
// Chan 7, 16-bit wide, Medium priority, memory increments
AUDIO_DMA_Stream->CR &= ~DMA_SxCR_EN ; // Disable DMA
@@ -108,6 +94,7 @@ void dacInit()
AUDIO_DMA_Stream->FCR = 0x05 ; //DMA_SxFCR_DMDIS | DMA_SxFCR_FTH_0 ;
// AUDIO_DMA_Stream->NDTR = 100 ;
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_DAC1);
DAC->DHR12R1 = 2010 ;
DAC->SR = DAC_SR_DMAUDR1 ; // Write 1 to clear flag
DAC->CR = DAC_CR_TEN1 | DAC_CR_EN1 ; // Enable DAC
@@ -117,7 +104,7 @@ void dacInit()
NVIC_SetPriority(AUDIO_DMA_Stream_IRQn, 7);
}
#if defined(AUDIO_MUTE_GPIO_PIN)
#if defined(AUDIO_MUTE_GPIO)
void audioMute()
{
if (!g_eeGeneral.audioMuteEnable) return;
@@ -129,7 +116,7 @@ void audioMute()
}
else if (now - audioQueue.lastAudioPlayTime > AUDIO_MUTE_DELAY / 10) {
// delay expired, we may mute
setMutePin(true);
setMutePin(true);
}
#else
// mute
@@ -164,7 +151,7 @@ void audioConsumeCurrentBuffer()
if (!nextBuffer) {
nextBuffer = audioQueue.buffersFifo.getNextFilledBuffer();
if (nextBuffer) {
#if defined(AUDIO_MUTE_GPIO_PIN)
#if defined(AUDIO_MUTE_GPIO)
audioUnmute();
#endif
AUDIO_DMA_Stream->CR &= ~DMA_SxCR_EN; // Disable DMA channel
@@ -175,7 +162,7 @@ void audioConsumeCurrentBuffer()
DAC->SR = DAC_SR_DMAUDR1; // Write 1 to clear flag
DAC->CR |= DAC_CR_EN1 | DAC_CR_DMAEN1; // Enable DAC
}
#if defined(AUDIO_MUTE_GPIO_PIN)
#if defined(AUDIO_MUTE_GPIO)
else {
audioMute();
}
radio/src/targets/common/arm/stm32/bluetooth_driver.cpp
+11 -20
View File
@@ -20,7 +20,10 @@
*/
#include "bluetooth_driver.h"
#include "hal/gpio.h"
#include "stm32_hal_ll.h"
#include "stm32_gpio.h"
#include "board.h"
#include "debug.h"
@@ -33,8 +36,8 @@
static const stm32_usart_t btUSART = {
.USARTx = BT_USART,
.GPIOx = BT_USART_GPIO,
.GPIO_Pin = BT_TX_GPIO_PIN | BT_RX_GPIO_PIN,
.txGPIO = BT_TX_GPIO,
.rxGPIO = BT_RX_GPIO,
.IRQn = BT_USART_IRQn,
.IRQ_Prio = BT_USART_IRQ_PRIORITY,
.txDMA = nullptr,
@@ -57,16 +60,8 @@ void* _bt_usart_ctx = nullptr;
void bluetoothInit(uint32_t baudrate, bool enable)
{
#if defined(BT_EN_GPIO_PIN)
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = BT_EN_GPIO_PIN;
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
pinInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
pinInit.Pull = LL_GPIO_PULL_NO;
LL_GPIO_Init(BT_EN_GPIO, &pinInit);
#if defined(BT_EN_GPIO)
gpio_init(BT_EN_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
#if !defined(BOOT)
@@ -85,21 +80,17 @@ void bluetoothInit(uint32_t baudrate, bool enable)
}
#endif
#if defined(BT_EN_GPIO_PIN)
if (enable) {
LL_GPIO_ResetOutputPin(BT_EN_GPIO, BT_EN_GPIO_PIN);
} else {
LL_GPIO_SetOutputPin(BT_EN_GPIO, BT_EN_GPIO_PIN);
}
#if defined(BT_EN_GPIO)
gpio_write(BT_EN_GPIO, !enable);
#endif
}
#if !defined(BOOT)
void bluetoothDisable()
{
#if defined(BT_EN_GPIO_PIN)
#if defined(BT_EN_GPIO)
// close bluetooth (recent modules will go to bootloader mode)
LL_GPIO_SetOutputPin(BT_EN_GPIO, BT_EN_GPIO_PIN);
gpio_set(BT_EN_GPIO);
#endif
if (_bt_usart_ctx) {
STM32SerialDriver.deinit(_bt_usart_ctx);
radio/src/targets/common/arm/stm32/board_common.h
+2 -39
View File
@@ -28,58 +28,21 @@
#if !defined(SIMU) && !defined(BACKUP)
#if defined(STM32F4)
#include "stm32f4xx.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_syscfg.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_exti.h"
#include "stm32f4xx_tim.h"
#include "stm32f4xx_spi.h"
#include "stm32f4xx_pwr.h"
#include "stm32f4xx_dma.h"
#include "stm32f4xx_dbgmcu.h"
#include "misc.h"
#else
#include "stm32f2xx.h"
#include "stm32f2xx_rcc.h"
#include "stm32f2xx_syscfg.h"
#include "stm32f2xx_gpio.h"
#include "stm32f2xx_exti.h"
#include "stm32f2xx_tim.h"
#include "stm32f2xx_spi.h"
#include "stm32f2xx_pwr.h"
#include "stm32f2xx_dma.h"
#include "stm32f2xx_dbgmcu.h"
#include "misc.h"
#include "dwt.h" // the old ST library that we use does not define DWT register for STM32F2xx
#endif
#endif
//#include "usb_driver.h"
#if defined(SIMU)
#include "../simu/simpgmspace.h"
#endif
// Delays driver
#define SYSTEM_TICKS_1MS ((CPU_FREQ + 500) / 1000)
#define SYSTEM_TICKS_1US ((CPU_FREQ + 500000) / 1000000)
#define SYSTEM_TICKS_01US ((CPU_FREQ + 5000000) / 10000000)
#ifdef __cplusplus
extern "C" {
#endif
static inline uint32_t ticksNow()
{
#if !defined(SIMU) && !defined(BACKUP)
return DWT->CYCCNT;
#define ticksNow() ((uint32_t)(DWT->CYCCNT))
#else
return 0;
#endif
}
#ifdef __cplusplus
}
#define ticksNow() ((uint32_t)(0UL))
#endif
#include "delays_driver.h"
radio/src/targets/common/arm/stm32/bootloader/CMakeLists.txt
+1 -1
View File
@@ -62,7 +62,7 @@ if(PCB STREQUAL X10 OR PCB STREQUAL X12S OR PCB STREQUAL NV14 OR PCB STREQUAL PL
../../../../../targets/common/arm/stm32/spi_flash.cpp
../../../../../drivers/frftl.cpp
../../../../../crc.cpp
../../../../../targets/${TARGET_DIR}/sdram_driver.c
../../../../../targets/common/arm/stm32/sdram_driver.cpp
../../../../../targets/${TARGET_DIR}/haptic_driver.cpp
)
radio/src/targets/common/arm/stm32/bootloader/boot.cpp
+7 -11
View File
@@ -20,6 +20,7 @@
*/
#include "stm32_hal_ll.h"
#include "stm32_timer.h"
#include "hal/usb_driver.h"
#if defined(BLUETOOTH)
@@ -100,6 +101,7 @@ MemoryType memoryType;
uint32_t unlocked = 0;
void per5ms() {} // make linker happy
void per10ms()
{
tenms |= 1u; // 10 mS has passed
@@ -202,18 +204,12 @@ void writeEepromBlock()
#if !defined(SIMU)
void bootloaderInitApp()
{
RCC_AHB1PeriphClockCmd(PWR_RCC_AHB1Periph | LCD_RCC_AHB1Periph |
BACKLIGHT_RCC_AHB1Periph |
KEYS_BACKLIGHT_RCC_AHB1Periph,
ENABLE);
LL_AHB1_GRP1_EnableClock(LCD_RCC_AHB1Periph);
#if defined(LCD_RCC_APB2Periph)
LL_APB2_GRP1_EnableClock(LCD_RCC_APB2Periph);
#endif
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SYSCFG);
RCC_APB1PeriphClockCmd(ROTARY_ENCODER_RCC_APB1Periph | LCD_RCC_APB1Periph |
BACKLIGHT_RCC_APB1Periph,
ENABLE);
RCC_APB2PeriphClockCmd(
LCD_RCC_APB2Periph | BACKLIGHT_RCC_APB2Periph | RCC_APB2Periph_SYSCFG,
ENABLE);
#if defined(HAVE_BOARD_BOOTLOADER_INIT)
boardBootloaderInit();
radio/src/targets/common/arm/stm32/delays_driver.cpp
+5
View File
@@ -19,8 +19,13 @@
* GNU General Public License for more details.
*/
#include "delays_driver.h"
#include "board.h"
#define SYSTEM_TICKS_1MS ((CPU_FREQ + 500) / 1000)
#define SYSTEM_TICKS_1US ((CPU_FREQ + 500000) / 1000000)
#define SYSTEM_TICKS_01US ((CPU_FREQ + 5000000) / 10000000)
void delaysInit()
{
CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
radio/src/targets/common/arm/stm32/diskio_sdio.cpp
+3 -1
View File
@@ -21,11 +21,13 @@
#include "diskio_sdio.h"
#include "hal/gpio.h"
#include "stm32_dma.h"
#include "stm32_hal.h"
#include "stm32_hal_ll.h"
#include "stm32_gpio_driver.h"
#include "stm32_gpio.h"
#include "hal.h"
@@ -215,7 +217,7 @@ static DSTATUS sdio_status(BYTE lun)
DSTATUS stat = RES_OK;
#if defined(SD_PRESENT_GPIO)
if ((LL_GPIO_ReadInputPort(SD_PRESENT_GPIO) & SD_PRESENT_LL_GPIO_PIN) != 0) {
if (gpio_read(SD_PRESENT_GPIO)) {
stat |= STA_NODISK;
}
#endif
radio/src/targets/common/arm/stm32/f2/CMakeLists.txt
+1 -8
View File
@@ -45,22 +45,15 @@ if(NOT NATIVE_BUILD)
endif()
# StdPeriph library
set(STM32LIB_DIR ${THIRDPARTY_DIR}/STM32F2xx_StdPeriph_Lib_V1.1.0/Libraries)
include_directories(${STM32LIB_DIR}/STM32F2xx_StdPeriph_Driver/inc)
set(STM32LIB_DIR ${THIRDPARTY_DIR})
include_directories(${STM32LIB_DIR}/CMSIS/Device/ST/STM32F2xx/Include)
include_directories(${STM32LIB_DIR}/CMSIS/Include)
add_definitions(-DSTM32F2)
set(STM32_STDPERIPH_DIR ${STM32LIB_DIR}/STM32F2xx_StdPeriph_Driver)
add_library(stm32_stdperiph OBJECT EXCLUDE_FROM_ALL
targets/common/arm/stm32/f2/system_stm32f2xx.c
boards/generic_stm32/startup/startup_stm32f205xx.s
${STM32_STDPERIPH_DIR}/src/misc.c
${STM32_STDPERIPH_DIR}/src/stm32f2xx_gpio.c
${STM32_STDPERIPH_DIR}/src/stm32f2xx_dbgmcu.c
${STM32_STDPERIPH_DIR}/src/stm32f2xx_rcc.c
)
set(FIRMWARE_SRC ${FIRMWARE_SRC} $<TARGET_OBJECTS:stm32_stdperiph>)
radio/src/targets/common/arm/stm32/f2/system_stm32f2xx.c
+3 -2
View File
@@ -31,6 +31,7 @@
*/
#include "stm32f2xx.h"
#include "stm32_hal.h"
/**
* @}
@@ -87,8 +88,8 @@
uint32_t SystemCoreClock = 120000000;
__I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
__I uint8_t APBPrescTable[8] = {0, 0, 0, 0, 1, 2, 3, 4};
const uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
const uint8_t APBPrescTable[8] = {0, 0, 0, 0, 1, 2, 3, 4};
/**
* @}
radio/src/targets/common/arm/stm32/f4/CMakeLists.txt
+4 -11
View File
@@ -24,6 +24,7 @@ if(NOT NATIVE_BUILD)
add_library(stm32cube_ll OBJECT EXCLUDE_FROM_ALL
# LL drivers
${STM32CUBE_DIR}/Src/stm32f4xx_ll_gpio.c
${STM32CUBE_DIR}/Src/stm32f4xx_ll_fmc.c
${STM32CUBE_DIR}/Src/stm32f4xx_ll_tim.c
${STM32CUBE_DIR}/Src/stm32f4xx_ll_dma.c
${STM32CUBE_DIR}/Src/stm32f4xx_ll_usart.c
@@ -46,6 +47,8 @@ if(NOT NATIVE_BUILD)
${STM32CUBE_DIR}/Src/stm32f4xx_hal_dma.c
${STM32CUBE_DIR}/Src/stm32f4xx_hal_pcd.c
${STM32CUBE_DIR}/Src/stm32f4xx_hal_pcd_ex.c
${STM32CUBE_DIR}/Src/stm32f4xx_hal_flash.c
${STM32CUBE_DIR}/Src/stm32f4xx_hal_flash_ex.c
${STM32CUBE_DIR}/Src/stm32f4xx_hal_cortex.c
${STM32_COLORLCD_DRIVERS}
@@ -62,29 +65,19 @@ if(NOT NATIVE_BUILD)
endif()
# StdPeriph library
set(STM32LIB_DIR ${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries)
include_directories(${STM32LIB_DIR}/STM32F4xx_StdPeriph_Driver/inc)
set(STM32LIB_DIR ${THIRDPARTY_DIR})
include_directories(${STM32LIB_DIR}/CMSIS/Device/ST/STM32F4xx/Include)
include_directories(${STM32LIB_DIR}/CMSIS/Include)
add_definitions(-DSTM32F4)
set(STM32_STDPERIPH_DIR ${STM32LIB_DIR}/STM32F4xx_StdPeriph_Driver)
set(STM32_STDPERIPH_SRC
targets/common/arm/stm32/f4/system_stm32f4xx.c
${STM32_STDPERIPH_DIR}/src/misc.c
${STM32_STDPERIPH_DIR}/src/stm32f4xx_gpio.c
${STM32_STDPERIPH_DIR}/src/stm32f4xx_dbgmcu.c
${STM32_STDPERIPH_DIR}/src/stm32f4xx_rcc.c
${STM32_STDPERIPH_DIR}/src/stm32f4xx_flash.c
)
if(CPU_TYPE_FULL STREQUAL STM32F429xI)
set(STM32_STDPERIPH_SRC ${STM32_STDPERIPH_SRC}
boards/generic_stm32/startup/startup_stm32f42_43xxx.s
${STM32_STDPERIPH_DIR}/src/stm32f4xx_fmc.c
${STM32_STDPERIPH_DIR}/src/stm32f4xx_dma.c
)
elseif (CPU_TYPE_FULL STREQUAL STM32F413xG)
set(STM32_STDPERIPH_SRC ${STM32_STDPERIPH_SRC}
radio/src/targets/common/arm/stm32/f4/system_stm32f4xx.c
+5 -5
View File
@@ -120,7 +120,9 @@
* @{
*/
#include "stm32f4xx.h"
#include "thirdparty/CMSIS/Device/ST/STM32F4xx/Include/stm32f4xx.h"
#include "stm32_hal.h"
#include "stm32_hal_ll.h"
/**
* @}
@@ -195,8 +197,8 @@
uint32_t SystemCoreClock = 168000000;
#endif
__I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
__I uint8_t APBPrescTable[8] = {0, 0, 0, 0, 1, 2, 3, 4};
const uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
const uint8_t APBPrescTable[8] = {0, 0, 0, 0, 1, 2, 3, 4};
/**
* @}
@@ -257,10 +259,8 @@ void SystemInit(void)
#if defined(SDRAM)
void SDRAM_Init();
void FMC_SDRAMWriteProtectionConfig(uint32_t SDRAM_Bank, FunctionalState NewState);
SDRAM_Init(); // calls SDRAM_GPIOConfig()
FMC_SDRAMWriteProtectionConfig(((uint32_t)0x00000001), DISABLE);
#endif
#ifdef DATA_IN_ExtSRAM
radio/src/targets/common/arm/stm32/flash_driver.cpp
+9 -11
View File
@@ -19,20 +19,18 @@
* GNU General Public License for more details.
*/
#include "stm32_cmsis.h"
#include "stm32_hal.h"
#include "board.h"
#include "hal/watchdog_driver.h"
#if defined(STM32F4)
#include "stm32f4xx_flash.h"
#elif defined(STM32F2)
#include "stm32f2xx_flash.h"
#endif
void waitFlashIdle()
{
do {
WDG_RESET();
} while (FLASH->SR & FLASH_FLAG_BSY);
} while (FLASH->SR & FLASH_SR_BSY);
}
//After reset, write is not allowed in the Flash control register (FLASH_CR) to protect the
@@ -64,8 +62,8 @@ void eraseSector(uint32_t sector)
waitFlashIdle();
FLASH->CR &= CR_PSIZE_MASK;
FLASH->CR |= FLASH_PSIZE_WORD;
FLASH->CR &= ~FLASH_CR_PSIZE;
FLASH->CR |= FLASH_CR_PSIZE_1;
FLASH->CR &= SECTOR_MASK;
FLASH->CR |= FLASH_CR_SER | (sector << 3);
FLASH->CR |= FLASH_CR_STRT;
@@ -136,7 +134,7 @@ void flashWrite(uint32_t * address, const uint32_t * buffer) // page size is 256
#undef SECTOR_ADDRESS
#undef FLASH_BANK
for (uint32_t i=0; i<FLASH_PAGESIZE/4; i++) {
/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
be done by word */
@@ -144,8 +142,8 @@ void flashWrite(uint32_t * address, const uint32_t * buffer) // page size is 256
// Wait for last operation to be completed
waitFlashIdle();
FLASH->CR &= CR_PSIZE_MASK;
FLASH->CR |= FLASH_PSIZE_WORD;
FLASH->CR &= ~FLASH_CR_PSIZE;
FLASH->CR |= FLASH_CR_PSIZE_1;
FLASH->CR |= FLASH_CR_PG;
*address = *buffer;
radio/src/targets/common/arm/stm32/flysky_gimbal_driver.cpp
+4 -2
View File
@@ -21,10 +21,12 @@
#include "flysky_gimbal_driver.h"
#include "stm32_serial_driver.h"
#include "stm32_gpio.h"
#include "stm32_adc.h"
#include "delays_driver.h"
#include "hal/adc_driver.h"
#include "hal/gpio.h"
#include "hal.h"
#include "crc.h"
@@ -33,8 +35,8 @@
static const stm32_usart_t fsUSART = {
.USARTx = FLYSKY_HALL_SERIAL_USART,
.GPIOx = FLYSKY_HALL_SERIAL_GPIO,
.GPIO_Pin = FLYSKY_HALL_SERIAL_RX_GPIO_PIN,
.txGPIO = GPIO_UNDEF,
.rxGPIO = FLYSKY_HALL_SERIAL_RX_GPIO,
.IRQn = FLYSKY_HALL_SERIAL_USART_IRQn,
.IRQ_Prio = 6,
.txDMA = nullptr,
radio/src/targets/common/arm/stm32/heartbeat_driver.cpp
+8 -16
View File
@@ -19,8 +19,12 @@
* GNU General Public License for more details.
*/
#include "stm32_hal_ll.h"
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_exti_driver.h"
#include "stm32_hal_ll.h"
#include "mixer_scheduler.h"
#include "board.h"
#include "debug.h"
@@ -47,21 +51,9 @@ void init_intmodule_heartbeat()
{
TRACE("init_intmodule_heartbeat");
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = INTMODULE_HEARTBEAT_GPIO_PIN;
pinInit.Mode = LL_GPIO_MODE_INPUT;
pinInit.Speed = LL_GPIO_SPEED_FREQ_LOW;
pinInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
pinInit.Pull = LL_GPIO_PULL_UP;
LL_GPIO_Init(INTMODULE_HEARTBEAT_GPIO, &pinInit);
LL_SYSCFG_SetEXTISource(INTMODULE_HEARTBEAT_EXTI_PORT, INTMODULE_HEARTBEAT_EXTI_SYS_LINE);
stm32_exti_enable(INTMODULE_HEARTBEAT_EXTI_LINE, INTMODULE_HEARTBEAT_TRIGGER,
trigger_intmodule_heartbeat);
gpio_init_int(INTMODULE_HEARTBEAT_GPIO, GPIO_IN_PU,
INTMODULE_HEARTBEAT_TRIGGER,
trigger_intmodule_heartbeat);
heartbeatCapture.valid = true;
}
radio/src/targets/common/arm/stm32/pwr_driver.cpp
+25 -54
View File
@@ -19,68 +19,58 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "board.h"
#include "hal/abnormal_reboot.h"
void pwrInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
#if defined(INTMODULE_BOOTCMD_GPIO)
INIT_INTMODULE_BOOTCMD_PIN();
GPIO_InitStructure.GPIO_Pin = INTMODULE_BOOTCMD_GPIO_PIN;
GPIO_Init(INTMODULE_BOOTCMD_GPIO, &GPIO_InitStructure);
gpio_init(INTMODULE_BOOTCMD_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_write(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_DEFAULT);
#endif
// Internal module power
#if defined(HARDWARE_INTERNAL_MODULE)
gpio_init(INTMODULE_PWR_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
INTERNAL_MODULE_OFF();
GPIO_InitStructure.GPIO_Pin = INTMODULE_PWR_GPIO_PIN;
GPIO_Init(INTMODULE_PWR_GPIO, &GPIO_InitStructure);
#endif
// External module power
#if defined(HARDWARE_EXTERNAL_MODULE)
gpio_init(EXTMODULE_PWR_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
EXTERNAL_MODULE_PWR_OFF();
GPIO_InitStructure.GPIO_Pin = EXTMODULE_PWR_GPIO_PIN;
GPIO_Init(EXTMODULE_PWR_GPIO, &GPIO_InitStructure);
#endif
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
// PWR switch
#if defined(PWR_SWITCH_GPIO)
GPIO_InitStructure.GPIO_Pin = PWR_SWITCH_GPIO_PIN;
GPIO_Init(PWR_SWITCH_GPIO, &GPIO_InitStructure);
gpio_init(PWR_SWITCH_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
#endif
#if defined(PWR_EXTRA_SWITCH_GPIO)
// PWR Extra switch
GPIO_InitStructure.GPIO_Pin = PWR_EXTRA_SWITCH_GPIO_PIN;
GPIO_Init(PWR_EXTRA_SWITCH_GPIO, &GPIO_InitStructure);
gpio_init(PWR_EXTRA_SWITCH_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
#endif
#if defined(PCBREV_HARDCODED)
hardwareOptions.pcbrev = PCBREV_HARDCODED;
#elif defined(PCBREV_GPIO_PIN)
#elif defined(PCBREV_GPIO)
#if defined(PCBREV_GPIO_PULL_DOWN)
GPIO_ResetBits(PCBREV_GPIO, PCBREV_GPIO_PIN);
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
gpio_init(PCBREV_GPIO, GPIO_IN_PD, GPIO_PIN_SPEED_LOW);
#else
gpio_init(PCBREV_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
#endif
GPIO_InitStructure.GPIO_Pin = PCBREV_GPIO_PIN;
GPIO_Init(PCBREV_GPIO, &GPIO_InitStructure);
hardwareOptions.pcbrev = PCBREV_VALUE();
#elif defined(PCBREV_GPIO_1) && defined(PCBREV_GPIO_2)
gpio_init(PCBREV_GPIO_1, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
#if defined(PCBREV_TOUCH_GPIO_PIN)
#if defined(PCBREV_TOUCH_GPIO_PULL_UP)
GPIO_ResetBits(PCBREV_TOUCH_GPIO, PCBREV_TOUCH_GPIO_PIN);
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
gpio_init(PCBREV_GPIO_2, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
#else
gpio_init(PCBREV_TOUCH_GPIO, GPIO_IN_PD, GPIO_PIN_SPEED_LOW);
#endif
GPIO_InitStructure.GPIO_Pin = PCBREV_TOUCH_GPIO_PIN;
GPIO_Init(PCBREV_TOUCH_GPIO, &GPIO_InitStructure);
#endif
hardwareOptions.pcbrev = PCBREV_VALUE();
@@ -89,44 +79,32 @@ void pwrInit()
void pwrOn()
{
// we keep the init of the PIN to have pwrOn as quick as possible
#if defined(PWR_ON_GPIO)
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = PWR_ON_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(PWR_ON_GPIO, &GPIO_InitStructure);
GPIO_SetBits(PWR_ON_GPIO, PWR_ON_GPIO_PIN);
gpio_init(PWR_ON_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_set(PWR_ON_GPIO);
#endif
}
void pwrOff()
{
#if defined(PWR_ON_GPIO)
GPIO_ResetBits(PWR_ON_GPIO, PWR_ON_GPIO_PIN);
gpio_clear(PWR_ON_GPIO);
#endif
}
#if defined(PWR_EXTRA_SWITCH_GPIO)
bool pwrForcePressed()
{
return (GPIO_ReadInputDataBit(PWR_SWITCH_GPIO, PWR_SWITCH_GPIO_PIN) == Bit_RESET && GPIO_ReadInputDataBit(PWR_EXTRA_SWITCH_GPIO, PWR_EXTRA_SWITCH_GPIO_PIN) == Bit_RESET);
return !gpio_read(PWR_SWITCH_GPIO) && !gpio_read(PWR_EXTRA_SWITCH_GPIO);
}
#endif
bool pwrPressed()
{
#if defined(PWR_EXTRA_SWITCH_GPIO)
return (GPIO_ReadInputDataBit(PWR_SWITCH_GPIO, PWR_SWITCH_GPIO_PIN) ==
Bit_RESET ||
GPIO_ReadInputDataBit(PWR_EXTRA_SWITCH_GPIO,
PWR_EXTRA_SWITCH_GPIO_PIN) == Bit_RESET);
return !gpio_read(PWR_SWITCH_GPIO) && !gpio_read(PWR_EXTRA_SWITCH_GPIO);
#elif defined(PWR_SWITCH_GPIO)
return GPIO_ReadInputDataBit(PWR_SWITCH_GPIO, PWR_SWITCH_GPIO_PIN) ==
Bit_RESET;
return !gpio_read(PWR_SWITCH_GPIO);
#else
return true;
#endif
@@ -145,13 +123,6 @@ bool pwrOffPressed()
void pwrResetHandler()
{
RCC->AHB1ENR |= PWR_RCC_AHB1Periph;
// these two NOPs are needed (see STM32F errata sheet) before the peripheral
// register can be written after the peripheral clock was enabled
__ASM volatile ("nop");
__ASM volatile ("nop");
if (WAS_RESET_BY_WATCHDOG_OR_SOFTWARE()) {
pwrOn();
}
radio/src/targets/common/arm/stm32/rotary_encoder_driver.cpp
+3 -1
View File
@@ -29,6 +29,7 @@
#include "hal/rotary_encoder.h"
#include "board_common.h"
#include "stm32_timer.h"
#if !defined(BOOT)
#include "opentx.h"
@@ -153,7 +154,8 @@ void rotaryEncoderInit()
stm32_gpio_enable_clock(ROTARY_ENCODER_GPIO);
LL_GPIO_Init(ROTARY_ENCODER_GPIO, &pinInit);
stm32_timer_enable_clock(ROTARY_ENCODER_TIMER);
ROTARY_ENCODER_TIMER->ARR = 99; // 100uS
ROTARY_ENCODER_TIMER->PSC = (PERI1_FREQUENCY * TIMER_MULT_APB1) / 1000000 - 1; // 1uS
ROTARY_ENCODER_TIMER->CCER = 0;
radio/src/targets/common/arm/stm32/sdram_driver.cpp
+274
View File
@@ -0,0 +1,274 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_hal_ll.h"
#include "board.h"
#if defined(SDRAM_BANK1)
#define SDRAM_BANK FMC_SDRAM_BANK1
#define COMMAND_TARGET FMC_SDRAM_CMD_TARGET_BANK1
#elif defined(SDRAM_BANK2)
#define SDRAM_BANK FMC_SDRAM_BANK2
#define COMMAND_TARGET FMC_SDRAM_CMD_TARGET_BANK2
#else
#error "No bank definition for SDRAM"
#endif
#define SDRAM_MEMORY_WIDTH FMC_SDRAM_MEM_BUS_WIDTH_16
#define SDRAM_CAS_LATENCY FMC_SDRAM_CAS_LATENCY_3
#define SDRAM_READBURST FMC_SDRAM_RBURST_ENABLE
#define SDRAM_READPIPEDELAY FMC_SDRAM_RPIPE_DELAY_1
#define SDRAM_CLK_PERIOD FMC_SDRAM_CLOCK_PERIOD_2
#define SDRAM_MODEREG_BURST_LENGTH_1 ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_LENGTH_2 ((uint16_t)0x0001)
#define SDRAM_MODEREG_BURST_LENGTH_4 ((uint16_t)0x0002)
#define SDRAM_MODEREG_BURST_LENGTH_8 ((uint16_t)0x0004)
#define SDRAM_MODEREG_BURST_FULL_PAGE ((uint16_t)0x0007)
#define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED ((uint16_t)0x0008)
#define SDRAM_MODEREG_CAS_LATENCY_1 ((uint16_t)0x0010)
#define SDRAM_MODEREG_CAS_LATENCY_2 ((uint16_t)0x0020)
#define SDRAM_MODEREG_CAS_LATENCY_3 ((uint16_t)0x0030)
#define SDRAM_MODEREG_OPERATING_MODE_STANDARD ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE ((uint16_t)0x0200)
#define GPIO_AF_FMC GPIO_AF12
extern "C" void SDRAM_GPIOConfig(void)
{
/*-- GPIOs Configuration -----------------------------------------------------*/
/*
+-------------------+--------------------+--------------------+--------------------+
+ SDRAM pins assignment +
+-------------------+--------------------+--------------------+--------------------+
| PD0 <-> FMC_D2 | PE0 <-> FMC_NBL0 | PF0 <-> FMC_A0 | PG0 <-> FMC_A10 |
| PD1 <-> FMC_D3 | PE1 <-> FMC_NBL1 | PF1 <-> FMC_A1 | PG1 <-> FMC_A11 |
| PD8 <-> FMC_D13 | PE7 <-> FMC_D4 | PF2 <-> FMC_A2 | PG8 <-> FMC_SDCLK |
| PD9 <-> FMC_D14 | PE8 <-> FMC_D5 | PF3 <-> FMC_A3 | PG15 <-> FMC_NCAS |
| PD10 <-> FMC_D15 | PE9 <-> FMC_D6 | PF4 <-> FMC_A4 |--------------------+
| PD14 <-> FMC_D0 | PE10 <-> FMC_D7 | PF5 <-> FMC_A5 |
| PD15 <-> FMC_D1 | PE11 <-> FMC_D8 | PF11 <-> FMC_NRAS |
+-------------------| PE12 <-> FMC_D9 | PF12 <-> FMC_A6 |
| PE13 <-> FMC_D10 | PF13 <-> FMC_A7 |
| PE14 <-> FMC_D11 | PF14 <-> FMC_A8 |
| PE15 <-> FMC_D12 | PF15 <-> FMC_A9 |
+-------------------+--------------------+--------------------+
| PC3 <-> FMC_SDCKE0| PB5 <-> FMC_SDCKE1 |
| PH3 <-> FMC_SDNE0 | PH6 <-> FMC_SDNE1 |
| PH5 <-> FMC_SDNWE | |
+-------------------++-------------------+
*/
#if defined(SDRAM_BANK1)
/* GPIOC configuration */
gpio_init_af(GPIO_PIN(GPIOC, 3), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
#else
/* GPIOB configuration */
gpio_init_af(GPIO_PIN(GPIOB, 5), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
#endif
/* GPIOH configuration */
gpio_init_af(GPIO_PIN(GPIOH, 5), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
#if defined(SDRAM_BANK1)
gpio_init_af(GPIO_PIN(GPIOH, 3), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
#else
gpio_init_af(GPIO_PIN(GPIOH, 6), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
#endif
/* GPIOD configuration */
gpio_init_af(GPIO_PIN(GPIOD, 0), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOD, 1), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOD, 8), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOD, 9), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOD, 10), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOD, 14), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOD, 15), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
/* GPIOE configuration */
gpio_init_af(GPIO_PIN(GPIOE, 0), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 1), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 7), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 8), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 9), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 10), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 11), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 12), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 13), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 14), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOE, 15), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
/* GPIOF configuration */
gpio_init_af(GPIO_PIN(GPIOF, 0), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 1), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 2), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 3), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 4), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 5), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 11), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 12), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 13), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 14), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOF, 15), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
/* GPIOG configuration */
gpio_init_af(GPIO_PIN(GPIOG, 0), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOG, 1), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOG, 4), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOG, 5), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOG, 8), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(GPIO_PIN(GPIOG, 15), GPIO_AF_FMC, GPIO_PIN_SPEED_VERY_HIGH);
}
void SDRAM_InitSequence(void)
{
FMC_SDRAM_CommandTypeDef FMC_SDRAMCommandStructure;
uint32_t tmpr = 0;
/* Step 3 --------------------------------------------------------------------*/
/* Configure a clock configuration enable command */
FMC_SDRAMCommandStructure.CommandMode = FMC_SDRAM_CMD_CLK_ENABLE;
FMC_SDRAMCommandStructure.CommandTarget = COMMAND_TARGET;
FMC_SDRAMCommandStructure.AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while((__FMC_SDRAM_GET_FLAG(FMC_SDRAM_DEVICE, FMC_SDRAM_FLAG_BUSY) != 0));
/* Send the command */
FMC_SDRAM_SendCommand(FMC_SDRAM_DEVICE, &FMC_SDRAMCommandStructure, 10);
/* Step 4 --------------------------------------------------------------------*/
/* Insert 100 ms delay */
delay_ms(100);
/* Step 5 --------------------------------------------------------------------*/
/* Configure a PALL (precharge all) command */
FMC_SDRAMCommandStructure.CommandMode = FMC_SDRAM_CMD_PALL;
FMC_SDRAMCommandStructure.CommandTarget = COMMAND_TARGET;
FMC_SDRAMCommandStructure.AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while((__FMC_SDRAM_GET_FLAG(FMC_SDRAM_DEVICE, FMC_SDRAM_FLAG_BUSY) != 0));
/* Send the command */
FMC_SDRAM_SendCommand(FMC_SDRAM_DEVICE, &FMC_SDRAMCommandStructure, 10);
/* Step 6 --------------------------------------------------------------------*/
/* Configure a Auto-Refresh command */
FMC_SDRAMCommandStructure.CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
FMC_SDRAMCommandStructure.CommandTarget = COMMAND_TARGET;
FMC_SDRAMCommandStructure.AutoRefreshNumber = 4;
FMC_SDRAMCommandStructure.ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while((__FMC_SDRAM_GET_FLAG(FMC_SDRAM_DEVICE, FMC_SDRAM_FLAG_BUSY) != 0));
/* Send the command */
FMC_SDRAM_SendCommand(FMC_SDRAM_DEVICE, &FMC_SDRAMCommandStructure, 10);
/* Step 7 --------------------------------------------------------------------*/
/* Program the external memory mode register */
tmpr = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_2 |
SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL |
SDRAM_MODEREG_CAS_LATENCY_3 |
SDRAM_MODEREG_OPERATING_MODE_STANDARD |
SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
/* Configure a load Mode register command*/
FMC_SDRAMCommandStructure.CommandMode = FMC_SDRAM_CMD_LOAD_MODE;
FMC_SDRAMCommandStructure.CommandTarget = COMMAND_TARGET;
FMC_SDRAMCommandStructure.AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.ModeRegisterDefinition = tmpr;
/* Wait until the SDRAM controller is ready */
while((__FMC_SDRAM_GET_FLAG(FMC_SDRAM_DEVICE, FMC_SDRAM_FLAG_BUSY) != 0));
/* Send the command */
FMC_SDRAM_SendCommand(FMC_SDRAM_DEVICE, &FMC_SDRAMCommandStructure, 10);
/* Step 8: Set the refresh rate counter - refer to section SDRAM refresh timer register in RM0455 */
/* Set the device refresh rate
* COUNT = [(SDRAM self refresh time / number of row) x SDRAM CLK] – 20
= [(64ms/4096) * 84MHz] - 20 = 1312 - 20 ~ 1292 */
FMC_SDRAM_ProgramRefreshRate(FMC_SDRAM_DEVICE, 1292);
/* Wait until the SDRAM controller is ready */
while((__FMC_SDRAM_GET_FLAG(FMC_SDRAM_DEVICE, FMC_SDRAM_FLAG_BUSY) != 0));
}
extern "C" void SDRAM_Init(void)
{
//delay funcion needed
delaysInit();
// Clocks must be enabled here, because the sdramInit is called before main
LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_FMC);
/* GPIO configuration for FMC SDRAM bank */
SDRAM_GPIOConfig();
/* FMC Configuration ---------------------------------------------------------*/
FMC_SDRAM_InitTypeDef FMC_SDRAMInitStructure;
FMC_SDRAM_TimingTypeDef FMC_SDRAMTimingInitStructure;
/* FMC SDRAM Bank configuration */
/* Timing configuration for 84 Mhz of SD clock frequency (168Mhz/2) */
/* TMRD: 2 Clock cycles */
FMC_SDRAMTimingInitStructure.LoadToActiveDelay = 2;
/* TXSR: min=72ns (7x11.9ns) */
FMC_SDRAMTimingInitStructure.ExitSelfRefreshDelay = 7;
/* TRAS: min=42ns (4x11.9ns) max=120k (ns) */
FMC_SDRAMTimingInitStructure.SelfRefreshTime = 4;
/* TRC: min=60 (6x11.9ns) */
FMC_SDRAMTimingInitStructure.RowCycleDelay = 6;
/* TWR: 2 CLK */
FMC_SDRAMTimingInitStructure.WriteRecoveryTime = 2;
/* TRP: 15ns => 2x11.9ns */
FMC_SDRAMTimingInitStructure.RPDelay = 2;
/* TRCD: 15ns => 2x11.9ns */
FMC_SDRAMTimingInitStructure.RCDDelay = 2;
/* FMC SDRAM control configuration */
FMC_SDRAMInitStructure.SDBank = SDRAM_BANK;
/* Row addressing: [7:0] */
FMC_SDRAMInitStructure.ColumnBitsNumber = FMC_SDRAM_COLUMN_BITS_NUM_8;
/* Column addressing: [11:0] */
FMC_SDRAMInitStructure.RowBitsNumber = FMC_SDRAM_ROW_BITS_NUM_12;
FMC_SDRAMInitStructure.MemoryDataWidth = SDRAM_MEMORY_WIDTH;
FMC_SDRAMInitStructure.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4;
FMC_SDRAMInitStructure.CASLatency = SDRAM_CAS_LATENCY;
FMC_SDRAMInitStructure.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
FMC_SDRAMInitStructure.SDClockPeriod = SDRAM_CLK_PERIOD;
FMC_SDRAMInitStructure.ReadBurst = SDRAM_READBURST;
FMC_SDRAMInitStructure.ReadPipeDelay = SDRAM_READPIPEDELAY;
// FMC_SDRAMInitStructure.FMC_SDRAMTimingStruct = &FMC_SDRAMTimingInitStructure;
/* FMC SDRAM bank initialization */
FMC_SDRAM_Init(FMC_SDRAM_DEVICE, &FMC_SDRAMInitStructure);
FMC_SDRAM_Timing_Init(FMC_SDRAM_DEVICE, &FMC_SDRAMTimingInitStructure, SDRAM_BANK);
/* FMC SDRAM device initialization sequence */
SDRAM_InitSequence();
FMC_SDRAM_WriteProtection_Disable(FMC_SDRAM_DEVICE, SDRAM_BANK);
}
radio/src/targets/common/arm/stm32/stm32_exti_driver.cpp
+4
View File
@@ -98,6 +98,10 @@ void stm32_exti_enable(uint32_t line, uint8_t trigger, stm32_exti_handler_t cb)
{
if (line > LL_EXTI_LINE_15) return;
#if defined(LL_APB2_GRP1_PERIPH_EXTI)
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_EXTI);
#endif
LL_EXTI_InitTypeDef EXTI_init;
LL_EXTI_StructInit(&EXTI_init);
radio/src/targets/common/arm/stm32/stm32_gpio.cpp
+170
View File
@@ -0,0 +1,170 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_exti_driver.h"
#include "stm32_gpio_driver.h"
#include "stm32_hal_ll.h"
static inline GPIO_TypeDef* _port(gpio_t pin)
{
return (GPIO_TypeDef*)(pin & ~(0x0f));
}
static inline int _port_num(gpio_t pin)
{
return (((pin - GPIOA_BASE) >> 10) & 0x0f);
}
static inline void _enable_clock(GPIO_TypeDef* port)
{
uint32_t reg_idx = (((uint32_t)port) - GPIOA_BASE) >> 10;
LL_AHB1_GRP1_EnableClock(RCC_AHB1ENR_GPIOAEN << reg_idx);
}
static inline int _pin_num(gpio_t pin)
{
return (pin & 0x0f);
}
static inline void _set_mode(GPIO_TypeDef* port, int pin_num, unsigned mode)
{
uint32_t tmp = port->MODER;
tmp &= ~(0x3 << (2 * pin_num));
tmp |= ((mode & 0x3) << (2 * pin_num));
port->MODER = tmp;
}
static inline unsigned _get_mode(GPIO_TypeDef* port, int pin_num)
{
uint32_t tmp = port->MODER;
tmp >>= (2 * pin_num);
return tmp & 0x03;
}
void gpio_init(gpio_t pin, gpio_mode_t mode, gpio_speed_t speed)
{
GPIO_TypeDef* port = _port(pin);
int pin_num = _pin_num(pin);
_enable_clock(port);
_set_mode(port, pin, mode);
// pull up/down
port->PUPDR &= ~(0x3 << (2 * pin_num));
port->PUPDR |= (((mode >> 2) & 0x3) << (2 * pin_num));
// output mode
port->OTYPER &= ~(1 << pin_num);
port->OTYPER |= (((mode >> 4) & 0x1) << pin_num);
// pin speed to max
port->OSPEEDR |= (speed << (2 * pin_num));
}
void gpio_init_int(gpio_t pin, gpio_mode_t mode, gpio_flank_t flank, gpio_cb_t cb)
{
int port_num = _port_num(pin);
int pin_num = _pin_num(pin);
gpio_init(pin, mode, GPIO_PIN_SPEED_LOW);
// enable specific pin as exti sources
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SYSCFG);
SYSCFG->EXTICR[pin_num >> 2] &= ~(0xf << ((pin_num & 0x03) * 4));
SYSCFG->EXTICR[pin_num >> 2] |= (port_num << ((pin_num & 0x03) * 4));
stm32_exti_enable(1 << pin_num, (uint8_t)flank, cb);
}
void gpio_int_disable(gpio_t pin)
{
int pin_num = _pin_num(pin);
stm32_exti_disable(1 << pin_num);
}
void gpio_init_af(gpio_t pin, gpio_af_t af, gpio_speed_t speed)
{
GPIO_TypeDef* port = _port(pin);
int pin_num = _pin_num(pin);
_enable_clock(port);
// set selected function
port->AFR[(pin_num > 7) ? 1 : 0] &= ~(0xf << ((pin_num & 0x07) * 4));
port->AFR[(pin_num > 7) ? 1 : 0] |= (af << ((pin_num & 0x07) * 4));
// pin speed to max
port->OSPEEDR |= (speed << (2 * pin_num));
_set_mode(port, pin_num, 2);
}
void gpio_init_analog(gpio_t pin)
{
GPIO_TypeDef* port = _port(pin);
int pin_num = _pin_num(pin);
_enable_clock(port);
_set_mode(port, pin_num, 3);
// PUPD has to be 0b00
port->PUPDR &= ~(0x3 << (2 * pin_num));
}
gpio_mode_t gpio_get_mode(gpio_t pin)
{
return _get_mode(_port(pin), _pin_num(pin));
}
int gpio_read(gpio_t pin)
{
return (_port(pin)->IDR & (1 << _pin_num(pin)));
}
void gpio_set(gpio_t pin)
{
_port(pin)->BSRR = (1 << _pin_num(pin));
}
void gpio_clear(gpio_t pin)
{
_port(pin)->BSRR = (1 << (_pin_num(pin) + 16));
}
void gpio_toggle(gpio_t pin)
{
if (gpio_read(pin)) {
gpio_clear(pin);
} else {
gpio_set(pin);
}
}
void gpio_write(gpio_t pin, int value)
{
if (value) {
gpio_set(pin);
} else {
gpio_clear(pin);
}
}
radio/src/targets/common/arm/stm32/stm32_gpio.h
+74
View File
@@ -0,0 +1,74 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#include "stm32_cmsis.h"
#include <stdint.h>
#define GPIO_UNDEF (0xffffffff)
// #define GPIO_PIN(x, y) ((GPIOA_BASE + (x << 10)) | y)
#define GPIO_PIN(x, y) ((intptr_t)x | y)
// Generate GPIO mode bitfields
//
// bit 0+1: pin mode (input / output)
// bit 2+3: pull resistor configuration
// bit 4: output type (0: push-pull, 1: open-drain)
//
#define _GPIO_MODE(io, pr, ot) ((io << 0) | (pr << 2) | (ot << 4))
enum {
GPIO_IN = _GPIO_MODE(0, 0, 0), // input w/o pull R
GPIO_IN_PD = _GPIO_MODE(0, 2, 0), // input with pull-down
GPIO_IN_PU = _GPIO_MODE(0, 1, 0), // input with pull-up
GPIO_OUT = _GPIO_MODE(1, 0, 0), // push-pull output
GPIO_OD = _GPIO_MODE(1, 0, 1), // open-drain w/o pull R
GPIO_OD_PU = _GPIO_MODE(1, 1, 1) // open-drain with pull-up
};
enum {
GPIO_AF0 = 0,
GPIO_AF1,
GPIO_AF2,
GPIO_AF3,
GPIO_AF4,
GPIO_AF5,
GPIO_AF6,
GPIO_AF7,
GPIO_AF8,
GPIO_AF9,
GPIO_AF10,
GPIO_AF11,
GPIO_AF12,
GPIO_AF13,
GPIO_AF14,
GPIO_AF15,
GPIO_AF_UNDEF
};
enum {
GPIO_PIN_SPEED_LOW = 0x00,
GPIO_PIN_SPEED_MEDIUM = 0x01,
GPIO_PIN_SPEED_HIGH = 0x02,
GPIO_PIN_SPEED_VERY_HIGH = 0x03,
};
radio/src/targets/common/arm/stm32/stm32_gpio_driver.cpp
+1
View File
@@ -20,6 +20,7 @@
*/
#include "stm32_gpio_driver.h"
#include "stm32_hal_ll.h"
void stm32_gpio_enable_clock(GPIO_TypeDef *GPIOx)
{
radio/src/targets/common/arm/stm32/stm32_gpio_driver.h
+1 -1
View File
@@ -21,6 +21,6 @@
#pragma once
#include "stm32_hal_ll.h"
#include "stm32_cmsis.h"
void stm32_gpio_enable_clock(GPIO_TypeDef *GPIOx);
radio/src/targets/common/arm/stm32/stm32_hal_ll.h
+1
View File
@@ -35,6 +35,7 @@ extern "C" {
#if defined(STM32F4)
#define USE_RTOS 0U
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_bus.h"
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_fmc.h"
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_dma2d.h"
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_gpio.h"
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_tim.h"
radio/src/targets/common/arm/stm32/stm32_pulse_driver.cpp
+4 -16
View File
@@ -23,6 +23,7 @@
#include "stm32_gpio_driver.h"
#include "stm32_timer.h"
#include "stm32_dma.h"
#include "stm32_gpio.h"
#include "definitions.h"
@@ -76,20 +77,13 @@ int stm32_pulse_init(const stm32_pulse_timer_t* tim, uint32_t freq)
if (stm32_timer_is_clock_enabled(tim->TIMx)) return -1;
// .. and GPIO pin is not used
uint32_t pin_mode = LL_GPIO_GetPinMode(tim->GPIOx, tim->GPIO_Pin);
if (pin_mode != LL_GPIO_MODE_INPUT) return -1;
if(gpio_get_mode(tim->GPIO) != GPIO_IN) return -1;
if (tim->DMA_TC_CallbackPtr) {
memset(tim->DMA_TC_CallbackPtr, 0, sizeof(stm32_pulse_dma_tc_cb_t));
}
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = tim->GPIO_Pin;
pinInit.Mode = LL_GPIO_MODE_ALTERNATE;
pinInit.Alternate = tim->GPIO_Alternate;
stm32_gpio_enable_clock(tim->GPIOx);
LL_GPIO_Init(tim->GPIOx, &pinInit);
gpio_init_af(tim->GPIO, tim->GPIO_Alternate, GPIO_PIN_SPEED_MEDIUM);
LL_TIM_InitTypeDef timInit;
LL_TIM_StructInit(&timInit);
@@ -140,13 +134,7 @@ void stm32_pulse_deinit(const stm32_pulse_timer_t* tim)
LL_TIM_DeInit(tim->TIMx);
stm32_timer_disable_clock(tim->TIMx);
// Reconfigure pin as input
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = tim->GPIO_Pin;
pinInit.Mode = LL_GPIO_MODE_INPUT;
LL_GPIO_Init(tim->GPIOx, &pinInit);
gpio_init(tim->GPIO, GPIO_IN, GPIO_PIN_SPEED_MEDIUM);
}
static inline bool _is_complementary_channel(uint32_t channel)
radio/src/targets/common/arm/stm32/stm32_pulse_driver.h
+2 -2
View File
@@ -23,6 +23,7 @@
#include <stdint.h>
#include "stm32_hal_ll.h"
#include "hal/gpio.h"
struct stm32_pulse_timer_t;
typedef bool (*stm32_pulse_dma_tc_fct)(void*);
@@ -34,8 +35,7 @@ struct stm32_pulse_dma_tc_cb_t {
struct stm32_pulse_timer_t {
GPIO_TypeDef* GPIOx;
uint32_t GPIO_Pin;
gpio_t GPIO;
uint32_t GPIO_Alternate;
TIM_TypeDef* TIMx;
radio/src/targets/common/arm/stm32/stm32_softserial_driver.cpp
+23 -27
View File
@@ -22,6 +22,8 @@
#include "stm32_softserial_driver.h"
#include "stm32_exti_driver.h"
#include "stm32_timer.h"
#include "stm32_gpio.h"
#include "hal/gpio.h"
#include <string.h>
@@ -48,8 +50,7 @@ static void _softserial_exti()
// cheap debouncing...
for (uint8_t i = 0; i < 16; ++i) {
if (LL_GPIO_IsInputPinSet(port->GPIOx, port->GPIO_Pin) == 0)
return;
if (!gpio_read(port->GPIO)) return;
}
// enable timer counter
@@ -72,8 +73,7 @@ static bool _softserial_init_rx(const stm32_softserial_rx_port* port,
const etx_serial_init* params)
{
// Test if pin is in reset state
uint32_t mode = LL_GPIO_GetPinMode(port->GPIOx, port->GPIO_Pin);
if (mode != LL_GPIO_MODE_INPUT) return false;
if(gpio_get_mode(port->GPIO) != GPIO_IN) return false;
rxBitCount = 0;
rxBuffer = port->buffer.buffer;
@@ -98,45 +98,41 @@ static bool _softserial_init_rx(const stm32_softserial_rx_port* port,
NVIC_SetPriority(port->TIM_IRQn, 0);
NVIC_EnableIRQ(port->TIM_IRQn);
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
if (port->dir_GPIOx) {
pinInit.Pin = port->dir_Pin;
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
LL_GPIO_Init(port->dir_GPIOx, &pinInit);
if (port->dir_GPIO != GPIO_UNDEF) {
gpio_init(port->dir_GPIO, GPIO_OUT, GPIO_PIN_SPEED_MEDIUM);
if (!port->dir_Input) {
LL_GPIO_ResetOutputPin(port->dir_GPIOx, port->dir_Pin);
gpio_clear(port->dir_GPIO);
} else {
LL_GPIO_SetOutputPin(port->dir_GPIOx, port->dir_Pin);
gpio_set(port->dir_GPIO);
}
}
pinInit.Pin = port->GPIO_Pin;
pinInit.Mode = LL_GPIO_MODE_INPUT;
pinInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
pinInit.Pull = LL_GPIO_PULL_DOWN;
LL_GPIO_Init(port->GPIOx, &pinInit);
// pinInit.Pin = port->GPIO_Pin;
// pinInit.Mode = LL_GPIO_MODE_INPUT;
// pinInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
// pinInit.Pull = LL_GPIO_PULL_DOWN;
// LL_GPIO_Init(port->GPIOx, &pinInit);
// Connect EXTI line to TELEMETRY RX pin
LL_SYSCFG_SetEXTISource(port->EXTI_Port, port->EXTI_SysLine);
// LL_SYSCFG_SetEXTISource(port->EXTI_Port, port->EXTI_SysLine);
// Configure EXTI for raising edge (start bit; assuming inverted serial)
_softserialPort = port;
stm32_exti_enable(port->EXTI_Line, LL_EXTI_TRIGGER_RISING, _softserial_exti);
// stm32_exti_enable(port->EXTI_Line, LL_EXTI_TRIGGER_RISING, _softserial_exti);
gpio_init_int(port->GPIO, GPIO_IN_PD, GPIO_RISING, _softserial_exti);
return true;
}
static void _softserial_deinit_gpio(const stm32_softserial_rx_port* port)
{
// Reconfigure pin as input
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
gpio_init(port->GPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
// LL_GPIO_InitTypeDef pinInit;
// LL_GPIO_StructInit(&pinInit);
pinInit.Pin = port->GPIO_Pin;
pinInit.Mode = LL_GPIO_MODE_INPUT;
LL_GPIO_Init(port->GPIOx, &pinInit);
// pinInit.Pin = port->GPIO_Pin;
// pinInit.Mode = LL_GPIO_MODE_INPUT;
// LL_GPIO_Init(port->GPIOx, &pinInit);
}
static void _softserial_deinit_rx(const stm32_softserial_rx_port* port)
@@ -200,7 +196,7 @@ void stm32_softserial_rx_timer_isr(const stm32_softserial_rx_port* port)
rxByte >>= 1;
}
if (LL_GPIO_IsInputPinSet(port->GPIOx, port->GPIO_Pin) == 0)
if (!gpio_read(port->GPIO) == 0)
rxByte |= 0x80;
++rxBitCount;
radio/src/targets/common/arm/stm32/stm32_softserial_driver.h
+3 -4
View File
@@ -21,6 +21,7 @@
#include "stm32_serial_driver.h"
#include "stm32_pulse_driver.h"
#include "hal/gpio.h"
//
// RX soft-serial
@@ -33,8 +34,7 @@
//
struct stm32_softserial_rx_port {
GPIO_TypeDef* GPIOx;
uint32_t GPIO_Pin;
gpio_t GPIO;
TIM_TypeDef* TIMx;
uint32_t TIM_Freq;
IRQn_Type TIM_IRQn;
@@ -43,8 +43,7 @@ struct stm32_softserial_rx_port {
uint32_t EXTI_Line;
// Input/output direction pin
GPIO_TypeDef* dir_GPIOx;
uint32_t dir_Pin;
gpio_t dir_GPIO;
uint32_t dir_Input;
const stm32_serial_buffer buffer;
radio/src/targets/common/arm/stm32/stm32_timer.cpp
+34 -4
View File
@@ -33,8 +33,18 @@ void stm32_timer_enable_clock(TIM_TypeDef *TIMx)
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM4);
} else if (TIMx == TIM5) {
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM5);
} else if (TIMx == TIM6) {
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM6);
} else if (TIMx == TIM7) {
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM7);
} else if (TIMx == TIM8) {
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM8);
} else if (TIMx == TIM9) {
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM9);
} else if (TIMx == TIM10) {
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM10);
} else if (TIMx == TIM11) {
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM11);
} else if (TIMx == TIM12) {
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM12);
} else if (TIMx == TIM13) {
@@ -56,15 +66,25 @@ void stm32_timer_disable_clock(TIM_TypeDef *TIMx)
LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_TIM4);
} else if (TIMx == TIM5) {
LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_TIM5);
} else if (TIMx == TIM6) {
LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_TIM6);
} else if (TIMx == TIM7) {
LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_TIM7);
} else if (TIMx == TIM8) {
LL_APB2_GRP1_DisableClock(LL_APB2_GRP1_PERIPH_TIM8);
} else if (TIMx == TIM9) {
LL_APB2_GRP1_DisableClock(LL_APB2_GRP1_PERIPH_TIM9);
} else if (TIMx == TIM10) {
LL_APB2_GRP1_DisableClock(LL_APB2_GRP1_PERIPH_TIM10);
} else if (TIMx == TIM11) {
LL_APB2_GRP1_DisableClock(LL_APB2_GRP1_PERIPH_TIM11);
} else if (TIMx == TIM12) {
LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_TIM12);
} else if (TIMx == TIM13) {
LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_TIM13);
} else if (TIMx == TIM14) {
LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_TIM14);
}
}
}
bool stm32_timer_is_clock_enabled(TIM_TypeDef *TIMx)
@@ -79,14 +99,24 @@ bool stm32_timer_is_clock_enabled(TIM_TypeDef *TIMx)
return LL_APB1_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM4) != 0;
} else if (TIMx == TIM5) {
return LL_APB1_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM5) != 0;
} else if (TIMx == TIM6) {
return LL_APB1_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM6) != 0;
} else if (TIMx == TIM7) {
return LL_APB1_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM7) != 0;
} else if (TIMx == TIM8) {
return LL_APB2_GRP1_IsEnabledClock(LL_APB2_GRP1_PERIPH_TIM8) != 0;
} else if (TIMx == TIM9) {
return LL_APB2_GRP1_IsEnabledClock(LL_APB2_GRP1_PERIPH_TIM9) != 0;
} else if (TIMx == TIM10) {
return LL_APB2_GRP1_IsEnabledClock(LL_APB2_GRP1_PERIPH_TIM10) != 0;
} else if (TIMx == TIM11) {
return LL_APB2_GRP1_IsEnabledClock(LL_APB2_GRP1_PERIPH_TIM11) != 0;
} else if (TIMx == TIM12) {
return LL_APB2_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM12) != 0;
return LL_APB1_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM12) != 0;
} else if (TIMx == TIM13) {
return LL_APB2_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM13) != 0;
return LL_APB1_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM13) != 0;
} else if (TIMx == TIM14) {
return LL_APB2_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM14) != 0;
return LL_APB1_GRP1_IsEnabledClock(LL_APB1_GRP1_PERIPH_TIM14) != 0;
}
// not supported
radio/src/targets/common/arm/stm32/stm32_usart_driver.cpp
+28 -47
View File
@@ -20,8 +20,9 @@
*/
#include "stm32_usart_driver.h"
#include "stm32_gpio_driver.h"
#include "stm32_gpio.h"
#include "stm32_dma.h"
#include "hal/gpio.h"
#include <string.h>
@@ -35,6 +36,7 @@
// The new CMSIS can be used when StdPeriph is gone, as it mandates
// the old version located in "${STM32LIB_DIR}/CMSIS/Include"
//
#if 0
static inline uint32_t NVIC_GetEnableIRQ(IRQn_Type IRQn)
{
if ((int32_t)(IRQn) >= 0) {
@@ -46,7 +48,7 @@ static inline uint32_t NVIC_GetEnableIRQ(IRQn_Type IRQn)
return (0U);
}
}
#endif
static void _enable_usart_irq(const stm32_usart_t* usart)
{
NVIC_SetPriority(usart->IRQn, usart->IRQ_Prio);
@@ -143,27 +145,27 @@ static void disable_usart_clock(USART_TypeDef* USARTx)
}
static uint32_t _get_pin_speed(uint32_t baudrate)
static gpio_speed_t _get_pin_speed(uint32_t baudrate)
{
// 1 Mbps and above
if (baudrate >= 1000000) {
return LL_GPIO_SPEED_FREQ_VERY_HIGH;
return GPIO_PIN_SPEED_VERY_HIGH;
}
// 400kbps and above
else if (baudrate >= 400000) {
return LL_GPIO_SPEED_FREQ_HIGH;
return GPIO_PIN_SPEED_HIGH;
}
// under 400kbps
return LL_GPIO_SPEED_FREQ_LOW;
return GPIO_PIN_SPEED_LOW;
}
static uint32_t _get_usart_af(USART_TypeDef* USARTx)
static gpio_af_t _get_usart_af(USART_TypeDef* USARTx)
{
if (USARTx == USART1 || USARTx == USART2 || USARTx == USART3) {
return LL_GPIO_AF_7;
return GPIO_AF7;
} else {
return LL_GPIO_AF_8;
return GPIO_AF8;
}
}
@@ -224,29 +226,21 @@ void stm32_usart_deinit_rx_dma(const stm32_usart_t* usart)
bool stm32_usart_init(const stm32_usart_t* usart, const etx_serial_init* params)
{
// Test if the GPIO pins are in reset state
uint32_t pins = usart->GPIO_Pin;
while(pins != 0) {
uint32_t pin = 1 << POSITION_VAL(pins);
uint32_t mode = LL_GPIO_GetPinMode(usart->GPIOx, pin);
if (mode != LL_GPIO_MODE_INPUT) return false;
pins ^= pin;
if(gpio_get_mode(usart->txGPIO) != GPIO_IN || gpio_get_mode(usart->rxGPIO) != GPIO_IN)
{
return false;
}
enable_usart_clock(usart->USARTx);
LL_USART_DeInit(usart->USARTx);
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = usart->GPIO_Pin;
pinInit.Mode = LL_GPIO_MODE_ALTERNATE;
pinInit.Speed = _get_pin_speed(params->baudrate);
pinInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
pinInit.Pull = LL_GPIO_PULL_UP;
pinInit.Alternate = _get_usart_af(usart->USARTx);
stm32_gpio_enable_clock(usart->GPIOx);
LL_GPIO_Init(usart->GPIOx, &pinInit);
gpio_af_t af = _get_usart_af(usart->USARTx);
if (usart->rxGPIO != GPIO_UNDEF) {
gpio_init_af(usart->rxGPIO, af, _get_pin_speed(params->baudrate));
}
if (usart->txGPIO != GPIO_UNDEF) {
gpio_init_af(usart->txGPIO, af, _get_pin_speed(params->baudrate));
}
LL_USART_InitTypeDef usartInit;
LL_USART_StructInit(&usartInit);
@@ -330,13 +324,13 @@ void stm32_usart_deinit(const stm32_usart_t* usart)
LL_USART_DeInit(usart->USARTx);
disable_usart_clock(usart->USARTx);
// Reconfigure pin as output
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = usart->GPIO_Pin;
pinInit.Mode = LL_GPIO_MODE_INPUT;
LL_GPIO_Init(usart->GPIOx, &pinInit);
LL_GPIO_ResetOutputPin(usart->GPIOx, pinInit.Pin);
// Reconfigure pin as input
if (usart->rxGPIO != GPIO_UNDEF) {
gpio_init(usart->rxGPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
}
if (usart->txGPIO != GPIO_UNDEF) {
gpio_init(usart->txGPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
}
}
void stm32_usart_send_byte(const stm32_usart_t* usart, uint8_t byte)
@@ -508,19 +502,6 @@ void stm32_usart_set_baudrate(const stm32_usart_t* usart, uint32_t baudrate)
auto periphclk = _get_usart_periph_clock(usart->USARTx);
auto oversampling = LL_USART_GetOverSampling(usart->USARTx);
LL_USART_SetBaudRate(usart->USARTx, periphclk, oversampling, baudrate);
// update pin speed accordingly (must be done one-by-one)
uint32_t pin_speed = _get_pin_speed(baudrate);
uint32_t pindef = usart->GPIO_Pin;
// loop borrowed from LL_GPIO_init()
uint32_t pinpos = POSITION_VAL(pindef);
uint32_t currentpin = 0;
while ((pindef >> pinpos) != 0) {
currentpin = pindef & (1 << pinpos);
if (currentpin) LL_GPIO_SetPinSpeed(usart->GPIOx, currentpin, pin_speed);
pinpos++;
}
}
void stm32_usart_set_hw_option(const stm32_usart_t* usart, uint32_t option)
radio/src/targets/common/arm/stm32/stm32_usart_driver.h
+3 -2
View File
@@ -23,6 +23,7 @@
#include <stdint.h>
#include "hal/serial_driver.h"
#include "hal/gpio.h"
#include "stm32_hal_ll.h"
typedef void (*pin_setter_t)(uint8_t enable);
@@ -31,8 +32,8 @@ struct stm32_usart_t {
// USART defs
USART_TypeDef* USARTx;
GPIO_TypeDef* GPIOx;
uint32_t GPIO_Pin;
gpio_t txGPIO;
gpio_t rxGPIO;
// USART IRQ
IRQn_Type IRQn;
radio/src/targets/common/arm/stm32/stm32f4xx_hal_conf.h
+2 -2
View File
@@ -54,7 +54,7 @@
// #define HAL_NOR_MODULE_ENABLED
// #define HAL_PCCARD_MODULE_ENABLED
// #define HAL_SRAM_MODULE_ENABLED
// #define HAL_SDRAM_MODULE_ENABLED
#define HAL_SDRAM_MODULE_ENABLED
// #define HAL_HASH_MODULE_ENABLED
#define HAL_GPIO_MODULE_ENABLED
// #define HAL_EXTI_MODULE_ENABLED
@@ -101,7 +101,7 @@
#endif /* HSE_VALUE */
#if !defined (HSE_STARTUP_TIMEOUT)
#define HSE_STARTUP_TIMEOUT 100U /*!< Time out for HSE start up, in ms */
#define HSE_STARTUP_TIMEOUT 2000U /*!< Time out for HSE start up, in cycles through a loop, normal values seem to bs around 900 */
#endif /* HSE_STARTUP_TIMEOUT */
/**
radio/src/targets/common/arm/stm32/usb_driver.cpp
+14 -23
View File
@@ -37,6 +37,9 @@ extern "C" {
#include "stm32_hal_ll.h"
#include "stm32_hal.h"
#include "stm32_gpio.h"
#include "hal/gpio.h"
#include "hal/usb_driver.h"
#include "hal.h"
@@ -61,7 +64,7 @@ void setSelectedUsbMode(int mode)
selectedUsbMode = usbMode(mode);
}
#if defined(USB_GPIO_PIN_VBUS)
#if defined(USB_GPIO_VBUS)
int usbPlugged()
{
#if defined(DEBUG_DISABLE_USB)
@@ -71,8 +74,8 @@ int usbPlugged()
static uint8_t debouncedState = 0;
static uint8_t lastState = 0;
uint8_t state = LL_GPIO_IsInputPinSet(USB_GPIO, USB_GPIO_PIN_VBUS);
// uint8_t state = GPIO_ReadInputDataBit(USB_GPIO, USB_GPIO_PIN_VBUS);
uint8_t state = gpio_read(USB_GPIO_VBUS) ? 1 : 0;
if (state == lastState)
debouncedState = state;
else
@@ -92,27 +95,15 @@ extern "C" void OTG_FS_IRQHandler()
void usbInit()
{
// Initialize hardware
__HAL_RCC_GPIOA_CLK_ENABLE();
LL_GPIO_InitTypeDef GPIO_InitStruct;
LL_GPIO_StructInit(&GPIO_InitStruct);
#if defined(USB_GPIO_PIN_VBUS)
GPIO_InitStruct.Pin = USB_GPIO_PIN_VBUS;
GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Mode = LL_GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
LL_GPIO_Init(USB_GPIO, &GPIO_InitStruct);
gpio_init_af(USB_GPIO_DM, USB_GPIO_AF, GPIO_PIN_SPEED_VERY_HIGH);
gpio_init_af(USB_GPIO_DP, USB_GPIO_AF, GPIO_PIN_SPEED_VERY_HIGH);
#if defined(USB_GPIO_VBUS)
gpio_init(USB_GPIO_VBUS, GPIO_IN, GPIO_PIN_SPEED_LOW);
#endif
GPIO_InitStruct.Pin = USB_GPIO_PIN_DM | USB_GPIO_PIN_DP;
GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = LL_GPIO_AF_10; // USB
LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SYSCFG);
LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_OTGFS);
usbDriverStarted = false;
}
radio/src/targets/common/arm/stm32/vs1053b.cpp
+18 -39
View File
@@ -21,8 +21,11 @@
#include "stm32_hal_ll.h"
#include "stm32_gpio_driver.h"
#include "stm32_gpio.h"
#include "stm32_spi.h"
#include "hal/gpio.h"
#include "opentx.h"
#if !defined(SIMU)
@@ -310,31 +313,22 @@ void audioSendRiffHeader()
audioSpiWriteBuffer(RiffHeader, sizeof(RiffHeader));
}
#if defined(AUDIO_MUTE_GPIO_PIN)
#if defined(AUDIO_MUTE_GPIO)
static inline void setMutePin(bool enabled)
{
if (enabled) {
#if defined(INVERTED_MUTE_PIN)
GPIO_ResetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
#else
GPIO_SetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
enabled = !enabled;
#endif
} else {
#if defined(INVERTED_MUTE_PIN)
GPIO_SetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
#else
GPIO_ResetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
#endif
}
gpio_write(AUDIO_MUTE_GPIO, enabled);
}
static inline bool getMutePin(void)
{
bool muted = gpio_read(AUDIO_MUTE_GPIO) ? 1 : 0;
#if defined(INVERTED_MUTE_PIN)
return !GPIO_ReadOutputDataBit(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
#else
return GPIO_ReadOutputDataBit(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
muted = !muted;
#endif
return muted;
}
void audioMute()
@@ -374,42 +368,27 @@ void audioUnmute()
setMutePin(false);
#endif
}
void audioMuteInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = AUDIO_MUTE_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(AUDIO_MUTE_GPIO, &GPIO_InitStructure);
GPIO_ResetBits(AUDIO_MUTE_GPIO, AUDIO_MUTE_GPIO_PIN);
}
#endif
#if defined(PCBX12S)
void audioShutdownInit()
{
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
pinInit.Pin = AUDIO_SHUTDOWN_GPIO_PIN;
LL_GPIO_Init(AUDIO_SHUTDOWN_GPIO, &pinInit);
gpio_init(AUDIO_SHUTDOWN_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
// we never RESET it, there is a 2s delay on STARTUP
LL_GPIO_SetOutputPin(AUDIO_SHUTDOWN_GPIO, AUDIO_SHUTDOWN_GPIO_PIN);
gpio_set(AUDIO_SHUTDOWN_GPIO);
}
#endif
void audioInit()
{
#if defined(AUDIO_MUTE_GPIO_PIN)
audioMuteInit();
#if defined(AUDIO_MUTE_GPIO)
// Mute before init anything
gpio_init(AUDIO_MUTE_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
setMutePin(true);
#endif
#if defined(PCBX12S)
#if defined(PCBX12S)
audioShutdownInit();
#endif
@@ -451,7 +430,7 @@ void audioConsumeCurrentBuffer()
}
if (currentBuffer) {
#if defined(AUDIO_MUTE_GPIO_PIN)
#if defined(AUDIO_MUTE_GPIO)
audioUnmute();
#endif
uint32_t written = audioSpiWriteData(currentBuffer, currentSize);
@@ -463,7 +442,7 @@ void audioConsumeCurrentBuffer()
currentSize = 0;
}
}
#if defined(AUDIO_MUTE_GPIO_PIN)
#if defined(AUDIO_MUTE_GPIO)
else {
audioMute();
}
radio/src/targets/horus/CMakeLists.txt
+1 -1
View File
@@ -244,11 +244,11 @@ set(FIRMWARE_TARGET_SRC
board.cpp
backlight_driver.cpp
led_driver.cpp
sdram_driver.c
)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/sdram_driver.cpp
targets/common/arm/stm32/rotary_encoder_driver.cpp
targets/common/arm/stm32/heartbeat_driver.cpp
targets/common/arm/stm32/ads79xx.cpp
radio/src/targets/horus/backlight_driver.cpp
+9 -16
View File
@@ -19,6 +19,10 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
#include "opentx_types.h"
#include "board.h"
@@ -29,25 +33,14 @@
void backlightInit()
{
// PIN init
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource, BACKLIGHT_GPIO_AF);
gpio_init_af(BACKLIGHT_GPIO, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
#if defined(KEYS_BACKLIGHT_GPIO)
GPIO_InitStructure.GPIO_Pin = KEYS_BACKLIGHT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(KEYS_BACKLIGHT_GPIO, &GPIO_InitStructure);
gpio_init(KEYS_BACKLIGHT_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
// TIMER init
stm32_timer_enable_clock(BACKLIGHT_TIMER);
#if defined(PCBX12S) && PCBREV >= 13
BACKLIGHT_TIMER->ARR = 100;
BACKLIGHT_TIMER->PSC = BACKLIGHT_TIMER_FREQ / 10000 - 1; // 1kHz
@@ -89,10 +82,10 @@ void backlightEnable(uint8_t dutyCycle)
#if defined(KEYS_BACKLIGHT_GPIO) && !defined(BOOT)
if (dutyCycle == 0 || g_eeGeneral.keysBacklight == 0) {
GPIO_ResetBits(KEYS_BACKLIGHT_GPIO, KEYS_BACKLIGHT_GPIO_PIN);
gpio_clear(KEYS_BACKLIGHT_GPIO);
}
else {
GPIO_SetBits(KEYS_BACKLIGHT_GPIO, KEYS_BACKLIGHT_GPIO_PIN);
gpio_set(KEYS_BACKLIGHT_GPIO);
}
#endif
radio/src/targets/horus/board.cpp
+10 -40
View File
@@ -19,11 +19,16 @@
* GNU General Public License for more details.
*/
#include "stm32_hal.h"
#include "stm32_hal_ll.h"
#include "stm32_gpio.h"
#include "hal/adc_driver.h"
#include "hal/trainer_driver.h"
#include "hal/switch_driver.h"
#include "hal/rotary_encoder.h"
#include "hal/usb_driver.h"
#include "hal/gpio.h"
#include "board.h"
#include "boards/generic_stm32/module_ports.h"
@@ -51,37 +56,8 @@ bool boardBacklightOn = false;
void boardInit()
{
RCC_AHB1PeriphClockCmd(PWR_RCC_AHB1Periph |
PCBREV_RCC_AHB1Periph |
LED_RCC_AHB1Periph |
LCD_RCC_AHB1Periph |
BACKLIGHT_RCC_AHB1Periph |
KEYS_BACKLIGHT_RCC_AHB1Periph |
SD_RCC_AHB1Periph |
AUDIO_RCC_AHB1Periph |
TELEMETRY_RCC_AHB1Periph |
BT_RCC_AHB1Periph |
AUDIO_RCC_AHB1Periph |
HAPTIC_RCC_AHB1Periph |
INTMODULE_RCC_AHB1Periph |
EXTMODULE_RCC_AHB1Periph |
SPORT_UPDATE_RCC_AHB1Periph,
ENABLE);
RCC_APB1PeriphClockCmd(ROTARY_ENCODER_RCC_APB1Periph |
AUDIO_RCC_APB1Periph |
TELEMETRY_RCC_APB1Periph |
AUDIO_RCC_APB1Periph |
BACKLIGHT_RCC_APB1Periph,
ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG |
LCD_RCC_APB2Periph |
HAPTIC_RCC_APB2Periph |
TELEMETRY_RCC_APB2Periph |
BT_RCC_APB2Periph |
BACKLIGHT_RCC_APB2Periph,
ENABLE);
LL_AHB1_GRP1_EnableClock(LCD_RCC_AHB1Periph);
LL_APB2_GRP1_EnableClock(LCD_RCC_APB2Periph);
#if defined(RADIO_FAMILY_T16)
void board_set_bor_level();
@@ -140,7 +116,7 @@ void boardInit()
#if defined(DEBUG)
DBGMCU_APB1PeriphConfig(DBGMCU_IWDG_STOP|DBGMCU_TIM1_STOP|DBGMCU_TIM2_STOP|DBGMCU_TIM3_STOP|DBGMCU_TIM4_STOP|DBGMCU_TIM5_STOP|DBGMCU_TIM6_STOP|DBGMCU_TIM7_STOP|DBGMCU_TIM8_STOP|DBGMCU_TIM9_STOP|DBGMCU_TIM10_STOP|DBGMCU_TIM11_STOP|DBGMCU_TIM12_STOP|DBGMCU_TIM13_STOP|DBGMCU_TIM14_STOP, ENABLE);
// DBGMCU_APB1PeriphConfig(DBGMCU_IWDG_STOP|DBGMCU_TIM1_STOP|DBGMCU_TIM2_STOP|DBGMCU_TIM3_STOP|DBGMCU_TIM4_STOP|DBGMCU_TIM5_STOP|DBGMCU_TIM6_STOP|DBGMCU_TIM7_STOP|DBGMCU_TIM8_STOP|DBGMCU_TIM9_STOP|DBGMCU_TIM10_STOP|DBGMCU_TIM11_STOP|DBGMCU_TIM12_STOP|DBGMCU_TIM13_STOP|DBGMCU_TIM14_STOP, ENABLE);
#endif
ledInit();
@@ -176,14 +152,8 @@ void boardOff()
#if defined(PCBX12S)
// Shutdown the Audio amp
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = AUDIO_SHUTDOWN_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(AUDIO_SHUTDOWN_GPIO, &GPIO_InitStructure);
GPIO_ResetBits(AUDIO_SHUTDOWN_GPIO, AUDIO_SHUTDOWN_GPIO_PIN);
gpio_init(AUDIO_SHUTDOWN_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_clear(AUDIO_SHUTDOWN_GPIO);
#endif
// Shutdown the Haptic
radio/src/targets/horus/board.h
+7 -9
View File
@@ -22,6 +22,8 @@
#ifndef _BOARD_H_
#define _BOARD_H_
//#include "stm32_hal.h"
//#include "stm32_hal_ll.h"
#include "definitions.h"
#include "opentx_constants.h"
@@ -100,9 +102,6 @@ void flashWrite(uint32_t * address, const uint32_t * buffer);
uint32_t isFirmwareStart(const uint8_t * buffer);
uint32_t isBootloaderStart(const uint8_t * buffer);
// SDRAM driver
void SDRAM_Init();
#if defined(INTERNAL_MODULE_PXX1) || defined(INTERNAL_MODULE_PXX2)
#define HARDWARE_INTERNAL_RAS
#endif
@@ -118,21 +117,20 @@ void SDRAM_Init();
//
#define INTERNAL_MODULE_ON() \
do { \
GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN); \
gpio_set(INTMODULE_PWR_GPIO); \
delay_ms(1); \
} while (0)
#else
// Just turn the modue ON for all other targets
#define INTERNAL_MODULE_ON() \
GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define INTERNAL_MODULE_ON() gpio_set(INTMODULE_PWR_GPIO)
#endif
#define INTERNAL_MODULE_OFF() GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_ON() GPIO_SetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_OFF() GPIO_ResetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define INTERNAL_MODULE_OFF() gpio_clear(INTMODULE_PWR_GPIO)
#define EXTERNAL_MODULE_ON() gpio_set(EXTMODULE_PWR_GPIO)
#define EXTERNAL_MODULE_OFF() gpio_clear(EXTMODULE_PWR_GPIO)
#if !defined(PXX2)
#define IS_PXX2_INTERNAL_ENABLED() (false)
radio/src/targets/horus/hal.h
+131 -288
View File
@@ -77,10 +77,9 @@
#endif
// Rotary Encoder
#define ROTARY_ENCODER_RCC_APB1Periph RCC_APB1Periph_TIM12
#define ROTARY_ENCODER_GPIO GPIOH
#define ROTARY_ENCODER_GPIO_PIN_A GPIO_Pin_11 // PH.11
#define ROTARY_ENCODER_GPIO_PIN_B GPIO_Pin_10 // PH.10
#define ROTARY_ENCODER_GPIO_PIN_A LL_GPIO_PIN_11 // PH.11
#define ROTARY_ENCODER_GPIO_PIN_B LL_GPIO_PIN_10 // PH.10
#define ROTARY_ENCODER_POSITION() ((ROTARY_ENCODER_GPIO->IDR >> 10) & 0x03)
#define ROTARY_ENCODER_EXTI_LINE1 LL_EXTI_LINE_11
#define ROTARY_ENCODER_EXTI_LINE2 LL_EXTI_LINE_10
@@ -306,7 +305,7 @@
#define PWM_STICKS
#define PWM_TIMER TIM5
#define PWM_GPIO GPIOA
#define PWM_GPIO_AF GPIO_AF_TIM5
#define PWM_GPIO_AF GPIO_AF2
#define PWM_IRQHandler TIM5_IRQHandler
#define PWM_IRQn TIM5_IRQn
#define PWM_GPIOA_PINS (ADC_GPIO_PIN_STICK_LH | ADC_GPIO_PIN_STICK_LV | ADC_GPIO_PIN_STICK_RH | ADC_GPIO_PIN_STICK_RV)
@@ -372,158 +371,101 @@
// Power
#if defined(RADIO_T18)
#define PWR_RCC_AHB1Periph RCC_AHB1Periph_GPIOJ | RCC_AHB1Periph_GPIOB
#define PWR_ON_GPIO GPIOJ
#define PWR_ON_GPIO_PIN GPIO_Pin_1 // PJ.01
#define PWR_SWITCH_GPIO GPIOJ
#define PWR_SWITCH_GPIO_PIN GPIO_Pin_0 // PJ.00
#define PWR_EXTRA_SWITCH_GPIO GPIOB
#define PWR_EXTRA_SWITCH_GPIO_PIN GPIO_Pin_0 // PB.00
#define PWR_ON_GPIO GPIO_PIN(GPIOJ, 1) // PJ.01
#define PWR_SWITCH_GPIO GPIO_PIN(GPIOJ, 0) // PJ.00
#define PWR_EXTRA_SWITCH_GPIO GPIO_PIN(GPIOB, 0) // PB.00
#else
#define PWR_RCC_AHB1Periph RCC_AHB1Periph_GPIOJ
#define PWR_ON_GPIO GPIOJ
#define PWR_ON_GPIO_PIN GPIO_Pin_1 // PJ.01
#define PWR_SWITCH_GPIO GPIOJ
#define PWR_SWITCH_GPIO_PIN GPIO_Pin_0 // PJ.00
#define PWR_ON_GPIO GPIO_PIN(GPIOJ, 1) // PJ.01
#define PWR_SWITCH_GPIO GPIO_PIN(GPIOJ, 0) // PJ.00
#endif
// USB Charger
#if defined(USB_CHARGER)
#define USB_CHARGER_RCC_AHB1Periph RCC_AHB1Periph_GPIOG
#define USB_CHARGER_GPIO GPIOG
#define USB_CHARGER_GPIO_PIN GPIO_Pin_11 // PG.11
#define USB_USBDet_GPIO_PIN GPIO_Pin_13 // PG.13
#else
#define USB_CHARGER_RCC_AHB1Periph 0
#define USB_CHARGER_GPIO GPIO_PIN(GPIOG, 11) // PG.11
#define USB_USBDet_GPIO GPIO_PIN(GPIOG, 13) // PG.13
#endif
// S.Port update connector
#if defined(RADIO_FAMILY_T16)
#define SPORT_MAX_BAUDRATE 400000
#define SPORT_MAX_BAUDRATE 400000
#else
#define SPORT_MAX_BAUDRATE 250000 // < 400000
#define SPORT_MAX_BAUDRATE 250000 // < 400000
#endif
#if defined(PCBX10) && !defined(RADIO_FAMILY_T16)
#define SPORT_UPDATE_RCC_AHB1Periph RCC_AHB1Periph_GPIOH
#define SPORT_UPDATE_PWR_GPIO GPIOH
#define SPORT_UPDATE_PWR_GPIO_PIN GPIO_Pin_13 // PH.13
#else
#define SPORT_UPDATE_RCC_AHB1Periph 0
#define SPORT_UPDATE_PWR_GPIO GPIO_PIN(GPIOH, 13) // PH.13
#endif
// PCBREV
#if defined(PCBX10)
#define PCBREV_RCC_AHB1Periph RCC_AHB1Periph_GPIOH | RCC_AHB1Periph_GPIOA
#define PCBREV_GPIO GPIOH
#define PCBREV_GPIO_PIN (GPIO_Pin_7 | GPIO_Pin_8) // PH.07 | PH.08
#define PCBREV_TOUCH_GPIO GPIOA
#define PCBREV_TOUCH_GPIO_PIN GPIO_Pin_6 // PA.06
#define PCBREV_GPIO_1 GPIO_PIN(GPIOH, 7) // PH.07
#define PCBREV_GPIO_2 GPIO_PIN(GPIOH, 8) // PH.08
#define PCBREV_TOUCH_GPIO GPIO_PIN(GPIOA, 6) // PA.06
#define PCBREV_VALUE() ((gpio_read(PCBREV_GPIO_1) | gpio_read(PCBREV_GPIO_2)) >> 7)
#define PCBREV_TOUCH_GPIO_PULL_UP
#define PCBREV_VALUE() ((GPIO_ReadInputDataBit(PCBREV_GPIO, GPIO_Pin_7) + (GPIO_ReadInputDataBit(PCBREV_GPIO, GPIO_Pin_8) << 1)) * GPIO_ReadInputDataBit(PCBREV_TOUCH_GPIO, GPIO_Pin_6))
#else
#define PCBREV_RCC_AHB1Periph RCC_AHB1Periph_GPIOI
#define PCBREV_GPIO GPIOI
#define PCBREV_GPIO_PIN GPIO_Pin_11 // PI.11
#define PCBREV_VALUE() GPIO_ReadInputDataBit(PCBREV_GPIO, PCBREV_GPIO_PIN)
#define PCBREV_GPIO GPIO_PIN(GPIOI, 11) // PI.11
#define PCBREV_VALUE() (gpio_read(PCBREV_GPIO) >> 11)
#endif
// Led
#define STATUS_LEDS
#if defined(PCBX12S)
#define LED_RCC_AHB1Periph RCC_AHB1Periph_GPIOI
#define LED_GPIO GPIOI
#define LED_GPIO_PIN GPIO_Pin_5 // PI.05
#define LED_GPIO GPIO_PIN(GPIOI, 5) // PI.05
#elif defined(PCBX10)
#define LED_RCC_AHB1Periph RCC_AHB1Periph_GPIOE
#define LED_GPIO GPIOE
#define LED_RED_GPIO_PIN GPIO_Pin_2
#define LED_GREEN_GPIO_PIN GPIO_Pin_4
#define LED_BLUE_GPIO_PIN GPIO_Pin_5
#define LED_GPIO_PIN (LED_RED_GPIO_PIN | LED_GREEN_GPIO_PIN | LED_BLUE_GPIO_PIN)
#define LED_RED_GPIO GPIO_PIN(GPIOE, 2) // PE.02
#define LED_GREEN_GPIO GPIO_PIN(GPIOE, 4) // PE.04
#define LED_BLUE_GPIO GPIO_PIN(GPIOE, 5) // PE.05
#endif
// Serial Port (DEBUG)
#if defined(AUX_SERIAL)
#define AUX_SERIAL_GPIO GPIOB
#define AUX_SERIAL_GPIO_PIN_TX GPIO_Pin_10 // PB.10
#define AUX_SERIAL_GPIO_PIN_RX GPIO_Pin_11 // PB.11
#define AUX_SERIAL_GPIO_PinSource_TX GPIO_PinSource10
#define AUX_SERIAL_GPIO_PinSource_RX GPIO_PinSource11
#define AUX_SERIAL_GPIO_AF GPIO_AF_USART3
#define AUX_SERIAL_GPIO_AF_LL LL_GPIO_AF_7
#define AUX_SERIAL_TX_GPIO GPIO_PIN(GPIOB, 10) // PB.10
#define AUX_SERIAL_RX_GPIO GPIO_PIN(GPIOB, 11) // PB.11
#define AUX_SERIAL_USART USART3
#define AUX_SERIAL_USART_IRQHandler USART3_IRQHandler
#define AUX_SERIAL_USART_IRQn USART3_IRQn
#define AUX_SERIAL_DMA_TX DMA1
#define AUX_SERIAL_DMA_Stream_TX DMA1_Stream3
#define AUX_SERIAL_DMA_Stream_TX_LL LL_DMA_STREAM_3
#define AUX_SERIAL_DMA_Channel_TX LL_DMA_CHANNEL_4
#define AUX_SERIAL_DMA_TX_STREAM LL_DMA_STREAM_3
#define AUX_SERIAL_DMA_TX_CHANNEL LL_DMA_CHANNEL_4
#define AUX_SERIAL_DMA_RX DMA1
#define AUX_SERIAL_DMA_Stream_RX DMA1_Stream1
#define AUX_SERIAL_DMA_Stream_RX_LL LL_DMA_STREAM_1
#define AUX_SERIAL_DMA_Channel_RX LL_DMA_CHANNEL_4
#define AUX_SERIAL_DMA_RX_STREAM LL_DMA_STREAM_1
#define AUX_SERIAL_DMA_RX_CHANNEL LL_DMA_CHANNEL_4
#if defined(RADIO_TX16S)
#define AUX_SERIAL_PWR_GPIO GPIOA
#define AUX_SERIAL_PWR_GPIO_PIN GPIO_Pin_15 // PA.15
#define AUX_SERIAL_PWR_GPIO GPIO_PIN(GPIOA, 15) // PA.15
#endif
#endif
#if defined(AUX2_SERIAL)
#if defined(PCBX12S)
#define AUX2_SERIAL_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define AUX2_SERIAL_USART UART4
#define AUX2_SERIAL_GPIO_AF GPIO_AF_UART4
#define AUX2_SERIAL_GPIO_AF_LL LL_GPIO_AF_8
#define AUX2_SERIAL_USART_IRQn UART4_IRQn
#define AUX2_SERIAL_USART_IRQHandler UART4_IRQHandler
#define AUX2_SERIAL_GPIO GPIOA
#define AUX2_SERIAL_GPIO_PIN_TX GPIO_Pin_0 // PA.00
#define AUX2_SERIAL_GPIO_PIN_RX GPIO_Pin_1 // PA.01
#define AUX2_SERIAL_GPIO_TX_PinSource GPIO_PinSource0
#define AUX2_SERIAL_GPIO_RX_PinSource GPIO_PinSource1
#define AUX2_SERIAL_TX_GPIO GPIO_PIN(GPIOA, 0) // PA.00
#define AUX2_SERIAL_RX_GPIO GPIO_PIN(GPIOA, 1) // PA.01
#define AUX2_SERIAL_DMA_RX DMA1
#define AUX2_SERIAL_DMA_Stream_RX DMA1_Stream2
#define AUX2_SERIAL_DMA_Channel_RX LL_DMA_CHANNEL_4
#define AUX2_SERIAL_DMA_Stream_RX_LL LL_DMA_STREAM_2
#define AUX2_SERIAL_DMA_RX_STREAM LL_DMA_STREAM_2
#define AUX2_SERIAL_DMA_RX_CHANNEL LL_DMA_CHANNEL_4
#else
#define AUX2_SERIAL_RCC_AHB1Periph (RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_DMA2)
#define AUX2_SERIAL_USART USART6
#define AUX2_SERIAL_GPIO_AF GPIO_AF_USART6
#define AUX2_SERIAL_GPIO_AF_LL LL_GPIO_AF_8
#define AUX2_SERIAL_USART_IRQn USART6_IRQn
#define AUX2_SERIAL_USART_IRQHandler USART6_IRQHandler
#define AUX2_SERIAL_GPIO GPIOG
#define AUX2_SERIAL_GPIO_PIN_TX GPIO_Pin_14 // PG.14
#define AUX2_SERIAL_GPIO_PIN_RX GPIO_Pin_9 // PG.09
#define AUX2_SERIAL_GPIO_PinSource_TX GPIO_PinSource14
#define AUX2_SERIAL_GPIO_PinSource_RX GPIO_PinSource9
#define AUX2_SERIAL_TX_GPIO GPIO_PIN(GPIOG, 14) // PG.14
#define AUX2_SERIAL_RX_GPIO GPIO_PIN(GPIOG, 9) // PG.09
#define AUX2_SERIAL_DMA_RX DMA2
#define AUX2_SERIAL_DMA_Stream_RX DMA2_Stream1 // or DMA2_Stream2
#define AUX2_SERIAL_DMA_Channel_RX LL_DMA_CHANNEL_5
#define AUX2_SERIAL_DMA_Stream_RX_LL LL_DMA_STREAM_1
#define AUX2_SERIAL_DMA_RX_STREAM LL_DMA_STREAM_1 // or stream 2
#define AUX2_SERIAL_DMA_RX_CHANNEL LL_DMA_CHANNEL_5
#if !defined(RADIO_T18)
#define AUX2_SERIAL_PWR_GPIO GPIOB
#define AUX2_SERIAL_PWR_GPIO_PIN GPIO_Pin_0 // PB.00
#define AUX2_SERIAL_PWR_GPIO GPIO_PIN(GPIOB, 0) // PB.00
#endif
#endif
#else // AUX2_SERIAL
#define AUX2_SERIAL_RCC_AHB1Periph 0
#endif
// Telemetry
#define TELEMETRY_RCC_AHB1Periph (RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_DMA1)
#define TELEMETRY_RCC_APB1Periph RCC_APB1Periph_USART2
#define TELEMETRY_RCC_APB2Periph RCC_APB2Periph_TIM11
#define TELEMETRY_DIR_GPIO GPIOD
#define TELEMETRY_DIR_GPIO_PIN GPIO_Pin_4 // PD.04
#define TELEMETRY_DIR_GPIO GPIO_PIN(GPIOD, 4) // PD.04
#define TELEMETRY_SET_INPUT 0
#define TELEMETRY_GPIO GPIOD
#define TELEMETRY_TX_GPIO_PIN GPIO_Pin_5 // PD.05
#define TELEMETRY_RX_GPIO_PIN GPIO_Pin_6 // PD.06
#define TELEMETRY_GPIO_PinSource_TX GPIO_PinSource5
#define TELEMETRY_GPIO_PinSource_RX GPIO_PinSource6
#define TELEMETRY_GPIO_AF GPIO_AF_USART2
#define TELEMETRY_TX_GPIO GPIO_PIN(GPIOD, 5) // PD.05
#define TELEMETRY_RX_GPIO GPIO_PIN(GPIOD, 6) // PD.06
#define TELEMETRY_USART USART2
#define TELEMETRY_DMA DMA1
#if defined(PCBX12S)
@@ -559,23 +501,18 @@
#define EXTI4_IRQ_Priority 5
// USB
#define USB_RCC_AHB1Periph_GPIO RCC_AHB1Periph_GPIOA
#define USB_GPIO GPIOA
#define USB_GPIO_PIN_VBUS LL_GPIO_PIN_9 // PA.09
#define USB_GPIO_PIN_DM LL_GPIO_PIN_11 // PA.11
#define USB_GPIO_PIN_DP LL_GPIO_PIN_12 // PA.12
#define USB_GPIO_AF GPIO_AF_OTG1_FS
#define USB_GPIO_VBUS GPIO_PIN(GPIOA, 9) // PA.09
#define USB_GPIO_DM GPIO_PIN(GPIOA, 11) // PA.11
#define USB_GPIO_DP GPIO_PIN(GPIOA, 12) // PA.12
#define USB_GPIO_AF GPIO_AF10
// LCD
#define LCD_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOF | RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_GPIOJ | RCC_AHB1Periph_GPIOK | RCC_AHB1Periph_DMA2D)
#define LCD_RCC_APB1Periph 0
#define LCD_RCC_APB2Periph RCC_APB2Periph_LTDC
#define LCD_RCC_AHB1Periph LL_AHB1_GRP1_PERIPH_DMA2D
#define LCD_RCC_APB2Periph LL_APB2_GRP1_PERIPH_LTDC
#if defined(PCBX12S)
#define LCD_GPIO_NRST GPIOF
#define LCD_GPIO_PIN_NRST LL_GPIO_PIN_10 // PF.10
#define LCD_GPIO_NRST GPIO_PIN(GPIOF, 10) // PF.10
#elif defined(PCBX10)
#define LCD_GPIO_NRST GPIOI
#define LCD_GPIO_PIN_NRST LL_GPIO_PIN_10 // PI.10
#define LCD_GPIO_NRST GPIO_PIN(GPIOI, 10) // PI.10
#endif
#if defined(PCBX10) && !defined(RADIO_T18)
#define LCD_VERTICAL_INVERT
@@ -585,59 +522,38 @@
// Backlight
#if defined(PCBX12S)
#define BACKLIGHT_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define BACKLIGHT_GPIO GPIOA
#if PCBREV >= 13
#define BACKLIGHT_TIMER TIM5
#define BACKLIGHT_GPIO_PIN GPIO_Pin_3 // PA.03
#define BACKLIGHT_GPIO_PinSource GPIO_PinSource3
#define BACKLIGHT_RCC_APB1Periph RCC_APB1Periph_TIM5
#define BACKLIGHT_RCC_APB2Periph 0
#define BACKLIGHT_GPIO_AF GPIO_AF_TIM5
#define BACKLIGHT_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define BACKLIGHT_TIMER TIM5
#define BACKLIGHT_GPIO GPIO_PIN(GPIOA, 3) // PA.03
#define BACKLIGHT_GPIO_AF GPIO_AF2
#define BACKLIGHT_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#else
#define BACKLIGHT_TIMER TIM8
#define BACKLIGHT_GPIO_PIN GPIO_Pin_5 // PA.05
#define BACKLIGHT_GPIO_PinSource GPIO_PinSource5
#define BACKLIGHT_RCC_APB1Periph 0
#define BACKLIGHT_RCC_APB2Periph RCC_APB2Periph_TIM8
#define BACKLIGHT_GPIO_AF GPIO_AF_TIM8
#define BACKLIGHT_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#define BACKLIGHT_TIMER TIM8
#define BACKLIGHT_GPIO GPIO_PIN(GPIOA, 5) // PA.05
#define BACKLIGHT_GPIO_AF GPIO_AF3
#define BACKLIGHT_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#endif
#elif defined(PCBX10)
#define BACKLIGHT_RCC_AHB1Periph RCC_AHB1Periph_GPIOB
#define BACKLIGHT_GPIO GPIOB
#define BACKLIGHT_TIMER TIM8
#define BACKLIGHT_GPIO_PIN GPIO_Pin_1 // PB.01
#define BACKLIGHT_GPIO_PinSource GPIO_PinSource1
#define BACKLIGHT_RCC_APB1Periph 0
#define BACKLIGHT_RCC_APB2Periph RCC_APB2Periph_TIM8
#define BACKLIGHT_GPIO_AF GPIO_AF_TIM8
#define BACKLIGHT_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#define BACKLIGHT_TIMER TIM8
#define BACKLIGHT_GPIO GPIO_PIN(GPIOB, 1) // PB.01
#define BACKLIGHT_GPIO_AF GPIO_AF3
#define BACKLIGHT_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#endif
#if defined(RADIO_T18)
#define KEYS_BACKLIGHT_RCC_AHB1Periph RCC_AHB1Periph_GPIOC
#define KEYS_BACKLIGHT_GPIO GPIOC
#define KEYS_BACKLIGHT_GPIO_PIN GPIO_Pin_4 // PC.04
#define KEYS_BACKLIGHT_GPIO_PinSource GPIO_PinSource4
#else
#define KEYS_BACKLIGHT_RCC_AHB1Periph 0
#define KEYS_BACKLIGHT_GPIO GPIO_PIN(GPIOC, 4) // PC.04
#endif
// SD
#define SD_RCC_AHB1Periph (RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_DMA2)
#define SD_RCC_APB1Periph 0
#define SD_PRESENT_GPIO GPIOC
#define SD_PRESENT_GPIO_PIN GPIO_Pin_5 // PC.05
#define SD_PRESENT_LL_GPIO_PIN LL_GPIO_PIN_5 // PC.05
#define SD_SDIO_DMA DMA2
#define SD_SDIO_DMA_STREAM DMA2_Stream3 // or Stream6
#define SD_SDIO_DMA_CHANNEL LL_DMA_CHANNEL_4
#define SD_SDIO_DMA_IRQn DMA2_Stream3_IRQn
#define SD_SDIO_DMA_IRQHANDLER DMA2_Stream3_IRQHandler
#define SD_SDIO_CLK_DIV(fq) ((48000000 / (fq)) - 2)
#define SD_SDIO_INIT_CLK_DIV SD_SDIO_CLK_DIV(400000)
#define SD_SDIO_TRANSFER_CLK_DIV SD_SDIO_CLK_DIV(24000000)
#define SD_PRESENT_GPIO GPIO_PIN(GPIOC, 5) // PC.05
#define SD_SDIO_DMA DMA2
#define SD_SDIO_DMA_STREAM DMA2_Stream3 // or Stream6
#define SD_SDIO_DMA_CHANNEL LL_DMA_CHANNEL_4
#define SD_SDIO_DMA_IRQn DMA2_Stream3_IRQn
#define SD_SDIO_DMA_IRQHANDLER DMA2_Stream3_IRQHandler
#define SD_SDIO_CLK_DIV(fq) ((48000000 / (fq)) - 2)
#define SD_SDIO_INIT_CLK_DIV SD_SDIO_CLK_DIV(400000)
#define SD_SDIO_TRANSFER_CLK_DIV SD_SDIO_CLK_DIV(24000000)
#define STORAGE_USE_SDIO
// SPI NOR Flash
@@ -695,38 +611,26 @@
// Audio
#if defined(PCBX12S)
#define AUDIO_RCC_AHB1Periph (RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_GPIOH)
#define AUDIO_RCC_APB1Periph RCC_APB1Periph_SPI2
#define AUDIO_SHUTDOWN_GPIO GPIOI
#define AUDIO_SHUTDOWN_GPIO_PIN GPIO_Pin_9 // PI.09
#define AUDIO_SHUTDOWN_GPIO GPIO_PIN(GPIOI, 9) // PI.09
#define AUDIO_XDCS_GPIO GPIOI
#define AUDIO_XDCS_GPIO_PIN GPIO_Pin_0 // PI.00
#define AUDIO_XDCS_GPIO_PIN LL_GPIO_PIN_0 // PI.00
#define AUDIO_CS_GPIO GPIOH
#define AUDIO_CS_GPIO_PIN GPIO_Pin_13 // PH.13
#define AUDIO_CS_GPIO_PIN LL_GPIO_PIN_13 // PH.13
#define AUDIO_DREQ_GPIO GPIOH
#define AUDIO_DREQ_GPIO_PIN GPIO_Pin_14 // PH.14
#define AUDIO_DREQ_GPIO_PIN LL_GPIO_PIN_14 // PH.14
#define AUDIO_RST_GPIO GPIOH
#define AUDIO_RST_GPIO_PIN GPIO_Pin_15 // PH.15
#define AUDIO_RST_GPIO_PIN LL_GPIO_PIN_15 // PH.15
#define AUDIO_SPI SPI2
#define AUDIO_SPI_GPIO_AF GPIO_AF_SPI2
#define AUDIO_SPI_GPIO_AF LL_GPIO_AF_5
#define AUDIO_SPI_SCK_GPIO GPIOI
#define AUDIO_SPI_SCK_GPIO_PIN GPIO_Pin_1 // PI.01
#define AUDIO_SPI_SCK_GPIO_PinSource GPIO_PinSource1
#define AUDIO_SPI_SCK_GPIO_PIN LL_GPIO_PIN_1 // PI.01
#define AUDIO_SPI_MISO_GPIO GPIOI
#define AUDIO_SPI_MISO_GPIO_PIN GPIO_Pin_2 // PI.02
#define AUDIO_SPI_MISO_GPIO_PinSource GPIO_PinSource2
#define AUDIO_SPI_MISO_GPIO_PIN LL_GPIO_PIN_2 // PI.02
#define AUDIO_SPI_MOSI_GPIO GPIOI
#define AUDIO_SPI_MOSI_GPIO_PIN GPIO_Pin_3 // PI.03
#define AUDIO_SPI_MOSI_GPIO_PinSource GPIO_PinSource3
#define AUDIO_SPI_MOSI_GPIO_PIN LL_GPIO_PIN_3 // PI.03
#elif defined (PCBX10)
#define AUDIO_RCC_APB1Periph (RCC_APB1Periph_TIM6 | RCC_APB1Periph_DAC)
#define AUDIO_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_DMA1)
#define AUDIO_MUTE_GPIO GPIOA
#define AUDIO_MUTE_GPIO_PIN GPIO_Pin_7 // PA.07
#define AUDIO_OUTPUT_GPIO GPIOA
#define AUDIO_OUTPUT_GPIO_PIN GPIO_Pin_4 // PA.04
#define AUDIO_GPIO_AF GPIO_AF_DAC1
#define AUDIO_GPIO_PinSource GPIO_PinSource4
#define AUDIO_MUTE_GPIO GPIO_PIN(GPIOA, 7) // PA.07
#define AUDIO_OUTPUT_GPIO GPIO_PIN(GPIOA, 4) // PA.04
#define AUDIO_DMA_Stream DMA1_Stream5
#define AUDIO_DMA_Stream_IRQn DMA1_Stream5_IRQn
#define AUDIO_TIM_IRQn TIM6_DAC_IRQn
@@ -750,15 +654,11 @@
#if defined(HARDWARE_TOUCH)
#define TOUCH_I2C_BUS I2C_Bus_1
#define TOUCH_I2C_CLK_RATE 400000
#define TOUCH_INT_GPIO GPIOH
#define TOUCH_INT_GPIO_PIN LL_GPIO_PIN_2 // PH.02
#define TOUCH_RST_GPIO GPIOF
#define TOUCH_INT_GPIO GPIO_PIN(GPIOH, 2) // PH.02
#if defined(PCBX12S)
#define TOUCH_RST_GPIO_PIN LL_GPIO_PIN_7 // PF.7
#define TOUCH_RST_GPIO GPIO_PIN(GPIOF, 7) // PF.7
#else
#define TOUCH_RST_GPIO_PIN LL_GPIO_PIN_10 // PF.10
#define TOUCH_RST_GPIO GPIO_PIN(GPIOF, 10) // PF.10
#endif
#define TOUCH_INT_EXTI_Line LL_EXTI_LINE_2
#define TOUCH_INT_EXTI_Port LL_SYSCFG_EXTI_PORTH
@@ -816,158 +716,113 @@
// Haptic
#define HAPTIC_PWM
#if defined(PCBX12S)
#define HAPTIC_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define HAPTIC_RCC_APB2Periph RCC_APB2ENR_TIM9EN
#define HAPTIC_GPIO GPIOA
#define HAPTIC_GPIO_PIN GPIO_Pin_2
#define HAPTIC_GPIO GPIO_PIN(GPIOA, 2) // PA.02
#define HAPTIC_GPIO_TIMER TIM9
#define HAPTIC_GPIO_AF GPIO_AF_TIM9
#define HAPTIC_GPIO_PinSource GPIO_PinSource2
#define HAPTIC_GPIO_AF GPIO_AF3
#define HAPTIC_TIMER_OUTPUT_ENABLE TIM_CCER_CC1E
#define HAPTIC_TIMER_MODE TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2
#define HAPTIC_TIMER_COMPARE_VALUE HAPTIC_GPIO_TIMER->CCR1
#elif defined(PCBX10)
#define HAPTIC_RCC_AHB1Periph RCC_AHB1Periph_GPIOE
#define HAPTIC_RCC_APB2Periph RCC_APB2ENR_TIM9EN
#define HAPTIC_GPIO GPIOE
#define HAPTIC_GPIO_PIN GPIO_Pin_6 // PE.06
#define HAPTIC_GPIO GPIO_PIN(GPIOE, 6) // PE.06
#define HAPTIC_GPIO_TIMER TIM9
#define HAPTIC_GPIO_AF GPIO_AF_TIM9
#define HAPTIC_GPIO_PinSource GPIO_PinSource6
#define HAPTIC_GPIO_AF GPIO_AF3
#define HAPTIC_TIMER_OUTPUT_ENABLE TIM_CCER_CC2E
#define HAPTIC_TIMER_MODE TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2M_2
#define HAPTIC_TIMER_COMPARE_VALUE HAPTIC_GPIO_TIMER->CCR2
// FlySky Hall Sticks
#define FLYSKY_HALL_SERIAL_USART UART4
#define FLYSKY_HALL_SERIAL_GPIO GPIOA
#define FLYSKY_HALL_DMA_Channel LL_DMA_CHANNEL_4
#define FLYSKY_HALL_SERIAL_TX_GPIO_PIN LL_GPIO_PIN_0 // PA.00
#define FLYSKY_HALL_SERIAL_RX_GPIO_PIN LL_GPIO_PIN_1 // PA.01
#define FLYSKY_HALL_SERIAL_GPIO_AF LL_GPIO_AF_8
#define FLYSKY_HALL_SERIAL_USART_IRQHandler UART4_IRQHandler
#define FLYSKY_HALL_SERIAL_TX_GPIO GPIO_PIN(GPIOA, 0) // PA.00
#define FLYSKY_HALL_SERIAL_RX_GPIO GPIO_PIN(GPIOA, 1) // PA.01
#define FLYSKY_HALL_SERIAL_USART_IRQn UART4_IRQn
#define FLYSKY_HALL_SERIAL_DMA DMA1
#define FLYSKY_HALL_DMA_Stream_RX LL_DMA_STREAM_2
// #define FLYSKY_HALL_DMA_Stream_TX LL_DMA_STREAM_4
#endif
// Internal PXX1 Module:
// -> let's assume all internal XJT modules used are either X10 or X12S type
#define EXTERNAL_ANTENNA
#define INTMODULE_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_DMA2)
#define INTMODULE_PWR_GPIO GPIOA
#define INTMODULE_PWR_GPIO_PIN GPIO_Pin_8 // PA.08
#define INTMODULE_GPIO GPIOB
#define INTMODULE_TX_GPIO_PIN LL_GPIO_PIN_6 // PB.06
#define INTMODULE_RX_GPIO_PIN LL_GPIO_PIN_7 // PB.07
#define INTMODULE_PWR_GPIO GPIO_PIN(GPIOA, 8) // PA.08
#define INTMODULE_TX_GPIO GPIO_PIN(GPIOB, 6) // PB.06
#define INTMODULE_RX_GPIO GPIO_PIN(GPIOB, 7) // PB.07
#define INTMODULE_USART USART1
#define INTMODULE_GPIO_AF LL_GPIO_AF_7
#define INTMODULE_USART_IRQn USART1_IRQn
#define INTMODULE_USART_IRQHandler USART1_IRQHandler
#define INTMODULE_DMA DMA2
#define INTMODULE_DMA_STREAM LL_DMA_STREAM_7
#define INTMODULE_DMA_STREAM_IRQ DMA2_Stream7_IRQn
#define INTMODULE_DMA_STREAM_IRQHandler DMA2_Stream7_IRQHandler
#define INTMODULE_DMA_FLAG_TC DMA_FLAG_TCIF7
#define INTMODULE_DMA_CHANNEL LL_DMA_CHANNEL_4
#define INTMODULE_RX_DMA DMA2
#define INTMODULE_RX_DMA_STREAM LL_DMA_STREAM_2
#define INTMODULE_RX_DMA_CHANNEL LL_DMA_CHANNEL_4
#if defined(PCBX12S)
#define INTMODULE_BOOTCMD_GPIO GPIOC
#define INTMODULE_BOOTCMD_GPIO_PIN GPIO_Pin_2 // PC.02
#define INTMODULE_BOOTCMD_GPIO GPIO_PIN(GPIOC, 2) // PC.02
#elif defined(PCBX10)
#define INTMODULE_BOOTCMD_GPIO GPIOI
#define INTMODULE_BOOTCMD_GPIO_PIN GPIO_Pin_9 // PI.09
#define INTMODULE_BOOTCMD_GPIO GPIO_PIN(GPIOI, 9) // PI.09
#endif
#define INTMODULE_BOOTCMD_DEFAULT 0 // RESET
#define INIT_INTMODULE_BOOTCMD_PIN() GPIO_ResetBits(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_GPIO_PIN);
// External Module
#define EXTMODULE_PWR_GPIO GPIOB
#define EXTMODULE_PWR_GPIO_PIN GPIO_Pin_3 // PB.03
#define EXTERNAL_MODULE_PWR_OFF() GPIO_ResetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define EXTMODULE_PWR_GPIO GPIO_PIN(GPIOB, 3) // PB.03
#define EXTERNAL_MODULE_PWR_OFF() gpio_clear(EXTMODULE_PWR_GPIO)
#if defined(PCBX10) && defined(PCBREV_EXPRESS)
#define EXTMODULE_RCC_AHB1Periph (RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_DMA1)
#define EXTMODULE_TX_GPIO GPIOB
#define EXTMODULE_USART_GPIO EXTMODULE_TX_GPIO
#define EXTMODULE_TX_GPIO_PIN LL_GPIO_PIN_10 // PB.10 (TIM2_CH3)
#define EXTMODULE_RX_GPIO_PIN LL_GPIO_PIN_11 // PB.11
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM2
#define EXTMODULE_TX_GPIO GPIO_PIN(GPIOB, 10) // PB.10 (TIM2_CH3)
#define EXTMODULE_RX_GPIO GPIO_PIN(GPIOB, 11) // PB.11
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF1
#define EXTMODULE_TIMER TIM2
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH3
#define EXTMODULE_TIMER_32BITS
#define EXTMODULE_TIMER_DMA_SIZE (DMA_SxCR_PSIZE_1 | DMA_SxCR_MSIZE_1)
#define EXTMODULE_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define EXTMODULE_TIMER_IRQn TIM2_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM2_IRQHandler
#define EXTMODULE_TIMER_DMA_CHANNEL LL_DMA_CHANNEL_3
#define EXTMODULE_TIMER_DMA_STREAM DMA1_Stream1
#define EXTMODULE_TIMER_DMA DMA1
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_STREAM LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF1
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA1_Stream1_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA1_Stream1_IRQHandler
#define EXTMODULE_USART_GPIO_AF GPIO_AF_USART3
#define EXTMODULE_USART_GPIO_AF_LL LL_GPIO_AF_7
#define EXTMODULE_USART USART3
#define EXTMODULE_USART_IRQn USART3_IRQn
#define EXTMODULE_USART_IRQHandler USART3_IRQHandler
#define EXTMODULE_USART_TX_DMA DMA1
#define EXTMODULE_USART_TX_DMA_CHANNEL LL_DMA_CHANNEL_4
#define EXTMODULE_USART_TX_DMA_STREAM DMA1_Stream3
#define EXTMODULE_USART_TX_DMA_STREAM_LL LL_DMA_STREAM_3
#define EXTMODULE_USART_TX_DMA_STREAM LL_DMA_STREAM_3
#define EXTMODULE_USART_RX_DMA_CHANNEL LL_DMA_CHANNEL_4
#define EXTMODULE_USART_RX_DMA_STREAM DMA1_Stream1
#define EXTMODULE_USART_RX_DMA_STREAM_LL LL_DMA_STREAM_1
#define EXTMODULE_USART_RX_DMA_STREAM LL_DMA_STREAM_1
#elif defined(PCBX10) || PCBREV >= 13
#define EXTMODULE_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_DMA2)
#define EXTMODULE_TX_GPIO GPIOA
#define EXTMODULE_TX_GPIO_PIN GPIO_Pin_10 // PA.10 (TIM1_CH3)
#define EXTMODULE_TX_GPIO_PinSource GPIO_PinSource10
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM1
#define EXTMODULE_TX_GPIO GPIO_PIN(GPIOA, 10) // PA.10 (TIM1_CH3)
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF1
#define EXTMODULE_TIMER TIM1
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH3
#define EXTMODULE_TIMER_DMA_SIZE (DMA_SxCR_PSIZE_0 | DMA_SxCR_MSIZE_0)
#define EXTMODULE_TIMER_IRQn TIM1_UP_TIM10_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM1_UP_TIM10_IRQHandler
#define EXTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#define EXTMODULE_TIMER_DMA_CHANNEL LL_DMA_CHANNEL_6
#define EXTMODULE_TIMER_DMA_STREAM DMA2_Stream5
#define EXTMODULE_TIMER_DMA DMA2
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_5
#define EXTMODULE_TIMER_DMA_STREAM LL_DMA_STREAM_5
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream5_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA2_Stream5_IRQHandler
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF5
#else
#define EXTMODULE_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_DMA1)
#define EXTMODULE_TX_GPIO GPIOA
#define EXTMODULE_TX_GPIO_PIN GPIO_Pin_15 // PA.15 (TIM2_CH1)
#define EXTMODULE_TX_GPIO_PinSource GPIO_PinSource15
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM2
#define EXTMODULE_TX_GPIO GPIO_PIN(GPIOA, 15) // PA.15 (TIM2_CH1)
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF1
#define EXTMODULE_TIMER TIM2
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH1
#define EXTMODULE_TIMER_32BITS
#define EXTMODULE_TIMER_DMA_SIZE (DMA_SxCR_PSIZE_1 | DMA_SxCR_MSIZE_1)
#define EXTMODULE_TIMER_IRQn TIM2_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM2_IRQHandler
#define EXTMODULE_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define EXTMODULE_TIMER_DMA_CHANNEL LL_DMA_CHANNEL_3
#define EXTMODULE_TIMER_DMA_STREAM DMA1_Stream7
#define EXTMODULE_TIMER_DMA DMA1
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_7
#define EXTMODULE_TIMER_DMA_STREAM LL_DMA_STREAM_7
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA1_Stream7_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA1_Stream7_IRQHandler
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF7
#endif
// Heartbeat
#define INTMODULE_HEARTBEAT
#define INTMODULE_HEARTBEAT_RCC_AHB1Periph RCC_AHB1Periph_GPIOD
#define INTMODULE_HEARTBEAT_GPIO GPIOD
#define INTMODULE_HEARTBEAT_GPIO_PIN LL_GPIO_PIN_12 // PD.12 / TIM4_CH1
#define INTMODULE_HEARTBEAT_GPIO GPIO_PIN(GPIOD, 12) // PD.12 / TIM4_CH1
#define INTMODULE_HEARTBEAT_EXTI_PORT LL_SYSCFG_EXTI_PORTH
#define INTMODULE_HEARTBEAT_EXTI_SYS_LINE LL_SYSCFG_EXTI_LINE12
#define INTMODULE_HEARTBEAT_EXTI_LINE LL_EXTI_LINE_12
@@ -978,22 +833,18 @@
#endif
#define INTMODULE_HEARTBEAT_REUSE_INTERRUPT_ROTARY_ENCODER
#if defined(INTERNAL_MODULE_PXX2)
#define INTMODULE_HEARTBEAT_TRIGGER LL_EXTI_TRIGGER_FALLING
#define INTMODULE_HEARTBEAT_TRIGGER GPIO_FALLING
#else
#define INTMODULE_HEARTBEAT_TRIGGER LL_EXTI_TRIGGER_RISING
#define INTMODULE_HEARTBEAT_TRIGGER GPIO_RISING
#endif
// Trainer Port
#define TRAINER_GPIO GPIOC
#define TRAINER_IN_GPIO_PIN LL_GPIO_PIN_6 // PC.06
#define TRAINER_IN_GPIO GPIO_PIN(GPIOC, 6) // PC.06
#define TRAINER_IN_TIMER_Channel LL_TIM_CHANNEL_CH1
#define TRAINER_OUT_GPIO_PIN LL_GPIO_PIN_7 // PC.07
#define TRAINER_OUT_GPIO GPIO_PIN(GPIOC, 7) // PC.07
#define TRAINER_OUT_TIMER_Channel LL_TIM_CHANNEL_CH2
#define TRAINER_DETECT_GPIO GPIOB
#define TRAINER_DETECT_GPIO_PIN LL_GPIO_PIN_4 // PB.04
#define TRAINER_DETECT_GPIO GPIO_PIN(GPIOB, 4) // PB.04
#if !defined(PCBX10) || defined(RADIO_FAMILY_T16)
#define TRAINER_DETECT_INVERTED
#endif
@@ -1001,14 +852,13 @@
#define TRAINER_TIMER TIM3
#define TRAINER_TIMER_IRQn TIM3_IRQn
#define TRAINER_TIMER_IRQHandler TIM3_IRQHandler
#define TRAINER_GPIO_AF LL_GPIO_AF_2
#define TRAINER_GPIO_AF GPIO_AF2
#define TRAINER_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
// Trainer CPPM input on heartbeat pin
#define TRAINER_MODULE_CPPM_TIMER TIM4
#define TRAINER_MODULE_CPPM_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define TRAINER_MODULE_CPPM_GPIO INTMODULE_HEARTBEAT_GPIO
#define TRAINER_MODULE_CPPM_GPIO_PIN INTMODULE_HEARTBEAT_GPIO_PIN
#define TRAINER_MODULE_CPPM_TIMER_Channel LL_TIM_CHANNEL_CH1
#define TRAINER_MODULE_CPPM_TIMER_IRQn TIM4_IRQn
#define TRAINER_MODULE_CPPM_TIMER_IRQHandler TIM4_IRQHandler
@@ -1028,37 +878,30 @@
// Bluetooth
#define STORAGE_BLUETOOTH
#if defined(BLUETOOTH)
#define BT_RCC_APB2Periph RCC_APB2Periph_USART6
#define BT_USART USART6
#define BT_GPIO_AF LL_GPIO_AF_8
#define BT_USART_IRQn USART6_IRQn
#define BT_USART_GPIO GPIOG
#define BT_TX_GPIO_PIN LL_GPIO_PIN_14 // PG.14
#define BT_RX_GPIO_PIN LL_GPIO_PIN_9 // PG.09
#define BT_USART_IRQHandler USART6_IRQHandler
#else
#define BT_RCC_APB2Periph 0
#define BT_USART USART6
#define BT_USART_IRQn USART6_IRQn
#define BT_USART_GPIO GPIOG
#define BT_TX_GPIO GPIO_PIN(GPIOG, 14) // PG.14
#define BT_RX_GPIO GPIO_PIN(GPIOG, 9) // PG.09
#endif
#if defined(PCBX12S)
#if PCBREV >= 13
#define BT_RCC_AHB1Periph (RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_GPIOG)
#define BT_EN_GPIO GPIOI
#define BT_EN_GPIO_PIN LL_GPIO_PIN_10 // PI.10
#define BT_EN_GPIO GPIO_PIN(GPIOI, 10) // PI.10
#else
#define BT_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOG)
#define BT_EN_GPIO GPIOA
#define BT_EN_GPIO_PIN LL_GPIO_PIN_6 // PA.06
#define BT_EN_GPIO GPIO_PIN(GPIOA, 6) // PA.06
#endif
// #define BT_BRTS_GPIO GPIOG
// #define BT_BRTS_GPIO_PIN GPIO_Pin_10 // PG.10
// #define BT_BCTS_GPIO GPIOG
// #define BT_BCTS_GPIO_PIN GPIO_Pin_11 // PG.11
#elif defined(PCBX10)
#define BT_RCC_AHB1Periph RCC_AHB1Periph_GPIOG
#define BT_EN_GPIO GPIOG
#define BT_EN_GPIO_PIN LL_GPIO_PIN_10 // PG.10
#define BT_EN_GPIO GPIO_PIN(GPIOG, 10) // PG.10
#endif
// SDRAM
#define SDRAM_BANK2
#define LCD_W 480
#define LCD_H 272
#define LCD_PHYS_H LCD_H
radio/src/targets/horus/haptic_driver.cpp
+6 -10
View File
@@ -19,6 +19,10 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
#include "board.h"
void hapticOff(void)
@@ -36,16 +40,9 @@ void hapticOn(uint32_t pwmPercent)
void hapticInit(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = HAPTIC_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(HAPTIC_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(HAPTIC_GPIO, HAPTIC_GPIO_PinSource, HAPTIC_GPIO_AF);
gpio_init_af(HAPTIC_GPIO, HAPTIC_GPIO_AF, GPIO_PIN_SPEED_LOW);
stm32_timer_enable_clock(HAPTIC_GPIO_TIMER);
HAPTIC_GPIO_TIMER->ARR = 100;
HAPTIC_GPIO_TIMER->PSC = (PERI2_FREQUENCY * TIMER_MULT_APB2) / 10000 - 1;
HAPTIC_GPIO_TIMER->CCMR1 = HAPTIC_TIMER_MODE; // PWM
@@ -60,5 +57,4 @@ void hapticInit(void)
void hapticDone(void)
{
hapticOff();
RCC_AHB1PeriphClockCmd(HAPTIC_RCC_AHB1Periph, DISABLE);
}
radio/src/targets/horus/lcd_driver.cpp
+45 -47
View File
@@ -19,8 +19,11 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_hal_ll.h"
#include "stm32_hal.h"
#include "opentx_types.h"
#include "dma2d.h"
#include "hal.h"
@@ -49,6 +52,8 @@
#define VFP 2
#endif
#define GPIO_AF_LTDC GPIO_AF14
static LTDC_HandleTypeDef hltdc;
static void* initialFrameBuffer = nullptr;
@@ -181,72 +186,65 @@ static void startLcdRefresh(lv_disp_drv_t *disp_drv, uint16_t *buffer,
inline void LCD_NRST_LOW()
{
LL_GPIO_ResetOutputPin(LCD_GPIO_NRST, LCD_GPIO_PIN_NRST);
gpio_clear(LCD_GPIO_NRST);
}
inline void LCD_NRST_HIGH()
{
LL_GPIO_SetOutputPin(LCD_GPIO_NRST, LCD_GPIO_PIN_NRST);
gpio_set(LCD_GPIO_NRST);
}
static void LCD_AF_GPIOConfig()
{
LL_GPIO_InitTypeDef GPIO_InitStructure;
LL_GPIO_StructInit(&GPIO_InitStructure);
/* GPIOs Configuration */
/*
+------------------------+-----------------------+----------------------------+
+ LCD pins assignment +
+------------------------+-----------------------+----------------------------
| | LCD_TFT G2 <-> PJ.09 | |
| LCD_TFT R3 <-> PJ.02 | LCD_TFT G3 <-> PJ.10 | LCD_TFT B3 <-> PJ.15 |
| LCD_TFT R4 <-> PJ.03 | LCD_TFT G4 <-> PJ.11 | LCD_TFT B4 <-> PK.03 |
| LCD_TFT R5 <-> PJ.04 | LCD_TFT G5 <-> PK.00 | LCD_TFT B5 <-> PK.04 |
| LCD_TFT R6 <-> PJ.05 | LCD_TFT G6 <-> PK.01 | LCD_TFT B6 <-> PK.05 |
| LCD_TFT R7 <-> PJ.06 | LCD_TFT G7 <-> PK.02 | LCD_TFT B7 <-> PK.06 |
-------------------------------------------------------------------------------
| LCD_TFT HSYNC <-> PI.12 | LCDTFT VSYNC <-> PI.13 |
| LCD_TFT CLK <-> PI.14 | LCD_TFT DE <-> PK.07 ///
-----------------------------------------------------
| LCD_CS <-> PI.10 |LCD_SCK<->PI.11
-----------------------------------------------------
/* GPIOs Configuration */
/*
+------------------------+-----------------------+----------------------------+
+ LCD pins assignment +
+------------------------+-----------------------+----------------------------+
| | LCD_TFT G2 <-> PJ.09 | |
| LCD_TFT R3 <-> PJ.02 | LCD_TFT G3 <-> PJ.10 | LCD_TFT B3 <-> PJ.15 |
| LCD_TFT R4 <-> PJ.03 | LCD_TFT G4 <-> PJ.11 | LCD_TFT B4 <-> PK.03 |
| LCD_TFT R5 <-> PJ.04 | LCD_TFT G5 <-> PK.00 | LCD_TFT B5 <-> PK.04 |
| LCD_TFT R6 <-> PJ.05 | LCD_TFT G6 <-> PK.01 | LCD_TFT B6 <-> PK.05 |
| LCD_TFT R7 <-> PJ.06 | LCD_TFT G7 <-> PK.02 | LCD_TFT B7 <-> PK.06 |
-------------------------------------------------------------------------------
| LCD_TFT HSYNC <-> PI.12 | LCD_TFT VSYNC <-> PI.13 |
| LCD_TFT CLK <-> PI.14 | LCD_TFT DE <-> PK.07 |
--------------------------------------------------------
| LCD_CS <-> PI.10 | LCD_SCK<->PI.11 |
--------------------------------------------------------
*/
// GPIOI configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_12 | LL_GPIO_PIN_13 | LL_GPIO_PIN_14;
GPIO_InitStructure.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStructure.Mode = LL_GPIO_MODE_ALTERNATE;
GPIO_InitStructure.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStructure.Pull = LL_GPIO_PULL_NO;
GPIO_InitStructure.Alternate = LL_GPIO_AF_14; // AF LTDC
LL_GPIO_Init(GPIOI, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOI, 12), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOI, 13), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOI, 14), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
// GPIOJ configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_2 | LL_GPIO_PIN_3 | LL_GPIO_PIN_4 | LL_GPIO_PIN_5 | LL_GPIO_PIN_6
| LL_GPIO_PIN_9 | LL_GPIO_PIN_10 | LL_GPIO_PIN_11 | LL_GPIO_PIN_15;
LL_GPIO_Init(GPIOJ, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOJ, 2), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 3), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 4), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 5), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 6), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 9), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 10), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 11), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 15), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
// GPIOK configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_0 | LL_GPIO_PIN_1 | LL_GPIO_PIN_2 | LL_GPIO_PIN_3 | LL_GPIO_PIN_4
| LL_GPIO_PIN_5 | LL_GPIO_PIN_6 | LL_GPIO_PIN_7;
LL_GPIO_Init(GPIOK, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOK, 0), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 1), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 2), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 3), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 4), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 5), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 6), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 7), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
}
static void LCD_NRSTConfig(void)
{
LL_GPIO_InitTypeDef GPIO_InitStructure;
LL_GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.Pin = LCD_GPIO_PIN_NRST;
GPIO_InitStructure.Mode = LL_GPIO_MODE_OUTPUT;
GPIO_InitStructure.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStructure.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStructure.Pull = LL_GPIO_PULL_NO;
LL_GPIO_Init(LCD_GPIO_NRST, &GPIO_InitStructure);
gpio_init(LCD_GPIO_NRST, GPIO_OUT, GPIO_PIN_SPEED_LOW);
}
static void lcdReset(void)
radio/src/targets/horus/led_driver.cpp
+31 -22
View File
@@ -19,63 +19,72 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "board.h"
void ledInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = LED_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LED_GPIO, &GPIO_InitStructure);
#if defined(LED_GPIO)
gpio_init(LED_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
#if defined(LED_RED_GPIO)
gpio_init(LED_RED_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
#if defined(LED_GREEN_GPIO)
gpio_init(LED_GREEN_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
#if defined(LED_BLUE_GPIO)
gpio_init(LED_BLUE_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
}
#if defined(PCBX12S)
#if defined(LED_GPIO)
// Single GPIO for dual color LED
void ledOff()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = LED_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LED_GPIO, &GPIO_InitStructure);
gpio_init(LED_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
}
void ledRed()
{
ledInit();
GPIO_SetBits(LED_GPIO, LED_GPIO_PIN);
gpio_set(LED_GPIO);
}
void ledBlue()
{
ledInit();
GPIO_ResetBits(LED_GPIO, LED_GPIO_PIN);
gpio_clear(LED_GPIO);
}
#elif defined(PCBX10)
#elif defined(LED_RED_GPIO) && defined(LED_GREEN_GPIO) && defined(LED_BLUE_GPIO)
void ledOff()
{
GPIO_ResetBits(LED_GPIO, LED_GPIO_PIN);
gpio_clear(LED_RED_GPIO);
gpio_clear(LED_GREEN_GPIO);
gpio_clear(LED_BLUE_GPIO);
}
void ledRed()
{
ledOff();
GPIO_SetBits(LED_GPIO, LED_RED_GPIO_PIN);
gpio_set(LED_RED_GPIO);
}
void ledGreen()
{
ledOff();
GPIO_SetBits(LED_GPIO, LED_GREEN_GPIO_PIN);
gpio_set(LED_GREEN_GPIO);
}
void ledBlue()
{
ledOff();
GPIO_SetBits(LED_GPIO, LED_BLUE_GPIO_PIN);
gpio_set(LED_BLUE_GPIO);
}
#endif
radio/src/targets/horus/sdram_driver.c
-467
View File
@@ -1,467 +0,0 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "board.h"
#include "stm32f4xx_fmc.h"
#define SDRAM_MEMORY_WIDTH FMC_SDMemory_Width_16b
#define SDRAM_CAS_LATENCY FMC_CAS_Latency_3
#define SDCLOCK_PERIOD FMC_SDClock_Period_2
#define SDRAM_TIMEOUT ((uint32_t)0xFFFF)
/**
* @brief FMC SDRAM Mode definition register defines
*/
#define SDRAM_MODEREG_BURST_LENGTH_1 ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_LENGTH_2 ((uint16_t)0x0001)
#define SDRAM_MODEREG_BURST_LENGTH_4 ((uint16_t)0x0002)
#define SDRAM_MODEREG_BURST_LENGTH_8 ((uint16_t)0x0004)
#define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED ((uint16_t)0x0008)
#define SDRAM_MODEREG_CAS_LATENCY_2 ((uint16_t)0x0020)
#define SDRAM_MODEREG_CAS_LATENCY_3 ((uint16_t)0x0030)
#define SDRAM_MODEREG_OPERATING_MODE_STANDARD ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE ((uint16_t)0x0200)
/**
* @brief FMC SDRAM Memory Read Burst feature
*/
#define SDRAM_READBURST FMC_Read_Burst_Disable
static void __Delay(__IO uint32_t nCount)
{
__IO uint32_t index = 0;
for(index = (100000 * nCount); index != 0; index--)
{
}
}
/**
* @brief Configures all SDRAM memory I/Os pins.
* @param None.
* @retval None.
*/
void SDRAM_GPIOConfig(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOs clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD |
RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_GPIOF | RCC_AHB1Periph_GPIOG|RCC_AHB1Periph_GPIOH, ENABLE);
/*-- GPIOs Configuration -----------------------------------------------------*/
/*
+-------------------+--------------------+--------------------+--------------------+
+ SDRAM pins assignment +
+-------------------+--------------------+--------------------+--------------------+
| PD0 <-> FMC_D2 | PE0 <-> FMC_NBL0 | PF0 <-> FMC_A0 | PG0 <-> FMC_A10 |
| PD1 <-> FMC_D3 | PE1 <-> FMC_NBL1 | PF1 <-> FMC_A1 | PG1 <-> FMC_A11 |
| PD8 <-> FMC_D13 | PE7 <-> FMC_D4 | PF2 <-> FMC_A2 | PG8 <-> FMC_SDCLK |
| PD9 <-> FMC_D14 | PE8 <-> FMC_D5 | PF3 <-> FMC_A3 | PG15 <-> FMC_NCAS |
| PD10 <-> FMC_D15 | PE9 <-> FMC_D6 | PF4 <-> FMC_A4 |--------------------+
| PD14 <-> FMC_D0 | PE10 <-> FMC_D7 | PF5 <-> FMC_A5 |
| PD15 <-> FMC_D1 | PE11 <-> FMC_D8 | PF11 <-> FMC_NRAS |
+-------------------| PE12 <-> FMC_D9 | PF12 <-> FMC_A6 |
| PE13 <-> FMC_D10 | PF13 <-> FMC_A7 |
| PE14 <-> FMC_D11 | PF14 <-> FMC_A8 |
| PE15 <-> FMC_D12 | PF15 <-> FMC_A9 |
+-------------------+--------------------+--------------------+
| PB5 <-> FMC_SDCKE1|
| PB6 <-> FMC_SDNE1 |
| PH5 <-> FMC_SDNWE |///////
+-------------------+
*/
/* Common GPIO configuration */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
/* GPIOB configuration */
GPIO_PinAFConfig(GPIOB, GPIO_PinSource5 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 ;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* GPIOC configuration */
GPIO_PinAFConfig(GPIOH, GPIO_PinSource5 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOH, GPIO_PinSource6 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6;
GPIO_Init(GPIOH, &GPIO_InitStructure);
/* GPIOD configuration */
GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource8, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource9, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource10, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource14, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource15, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_8 |
GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_14 |
GPIO_Pin_15;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* GPIOE configuration */
GPIO_PinAFConfig(GPIOE, GPIO_PinSource0 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource1 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource7 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource8 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource9 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource10 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource11 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource12 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource13 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource14 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource15 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_7 |
GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 |
GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 |
GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOE, &GPIO_InitStructure);
/* GPIOF configuration */
GPIO_PinAFConfig(GPIOF, GPIO_PinSource0 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource1 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource2 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource3 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource4 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource5 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource11 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource12 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource13 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource14 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource15 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 |
GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 |
GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 |
GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOF, &GPIO_InitStructure);
/* GPIOG configuration */
GPIO_PinAFConfig(GPIOG, GPIO_PinSource0 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource1 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource4 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource5 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource8 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource15 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 |
GPIO_Pin_5 | GPIO_Pin_8 | GPIO_Pin_15;
GPIO_Init(GPIOG, &GPIO_InitStructure);
}
/**
* @brief Executes the SDRAM memory initialization sequence.
* @param None.
* @retval None.
*/
void SDRAM_InitSequence(void)
{
FMC_SDRAMCommandTypeDef FMC_SDRAMCommandStructure;
uint32_t tmpr = 0;
uint32_t timeout = SDRAM_TIMEOUT;
/* Step 3 --------------------------------------------------------------------*/
/* Configure a clock configuration enable command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_CLK_Enabled;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while((FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) && (timeout > 0))
{
timeout--;
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 4 --------------------------------------------------------------------*/
/* Insert 100 ms delay */
__Delay(10);
/* Step 5 --------------------------------------------------------------------*/
/* Configure a PALL (precharge all) command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_PALL;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
timeout = SDRAM_TIMEOUT;
while((FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) && (timeout > 0))
{
timeout--;
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 6 --------------------------------------------------------------------*/
/* Configure a Auto-Refresh command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_AutoRefresh;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 8;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
timeout = SDRAM_TIMEOUT;
while((FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) && (timeout > 0))
{
timeout--;
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 7 --------------------------------------------------------------------*/
/* Program the external memory mode register */
tmpr = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_1 |
SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL |
SDRAM_MODEREG_CAS_LATENCY_3 |
SDRAM_MODEREG_OPERATING_MODE_STANDARD |
SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
/* Configure a load Mode register command*/
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_LoadMode;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = tmpr;
/* Wait until the SDRAM controller is ready */
timeout = SDRAM_TIMEOUT;
while((FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) && (timeout > 0))
{
timeout--;
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 8 --------------------------------------------------------------------*/
/* Set the refresh rate counter */
/* (15.62 us x Freq) - 20 */
/* Set the device refresh counter */
FMC_SetRefreshCount(1385);
/* Wait until the SDRAM controller is ready */
timeout = SDRAM_TIMEOUT;
while((FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) && (timeout > 0))
{
timeout--;
}
}
/**
* @brief Executes the SDRAM memory initialization sequence.
* @param None.
* @retval None.
*/
void SDRAMTest_InitSequence(void)
{
FMC_SDRAMCommandTypeDef FMC_SDRAMCommandStructure;
uint32_t tmpr = 0;
/* Step 3 --------------------------------------------------------------------*/
/* Configure a clock configuration enable command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_CLK_Enabled;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank2;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank2_SDRAM, FMC_FLAG_Busy) != RESET)
{
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 4 --------------------------------------------------------------------*/
/* Insert 100 ms delay */
__Delay(10);
/* Step 5 --------------------------------------------------------------------*/
/* Configure a PALL (precharge all) command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_PALL;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank2;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank2_SDRAM, FMC_FLAG_Busy) != RESET)
{
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 6 --------------------------------------------------------------------*/
/* Configure a Auto-Refresh command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_AutoRefresh;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank2;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 4;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank2_SDRAM, FMC_FLAG_Busy) != RESET)
{
}
/* Send the first command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank2_SDRAM, FMC_FLAG_Busy) != RESET)
{
}
/* Send the second command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 7 --------------------------------------------------------------------*/
/* Program the external memory mode register */
tmpr = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_2 |
SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL |
SDRAM_MODEREG_CAS_LATENCY_3 |
SDRAM_MODEREG_OPERATING_MODE_STANDARD |
SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
/* Configure a load Mode register command*/
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_LoadMode;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank2;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = tmpr;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank2_SDRAM, FMC_FLAG_Busy) != RESET)
{
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 8 --------------------------------------------------------------------*/
/* Set the refresh rate counter */
/* (15.62 us x Freq) - 20 */
/* Set the device refresh counter */
FMC_SetRefreshCount(1386);
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank2_SDRAM, FMC_FLAG_Busy) != RESET)
{
}
}
void SDRAM_Init(void)
{
FMC_SDRAMInitTypeDef FMC_SDRAMInitStructure;
FMC_SDRAMTimingInitTypeDef FMC_SDRAMTimingInitStructure;
/* GPIO configuration for FMC SDRAM bank */
SDRAM_GPIOConfig();
/* Enable FMC clock */
RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FMC, ENABLE);
/* FMC Configuration ---------------------------------------------------------*/
/* FMC SDRAM Bank configuration */
/* Timing configuration for 90 Mhz of SD clock frequency (168Mhz/2) */
/* TMRD: 2 Clock cycles */
FMC_SDRAMTimingInitStructure.FMC_LoadToActiveDelay = 2;
/* TXSR: min=70ns (7x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_ExitSelfRefreshDelay = 7;
/* TRAS: min=42ns (4x11.11ns) max=120k (ns) */
FMC_SDRAMTimingInitStructure.FMC_SelfRefreshTime = 4;
/* TRC: min=70 (7x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_RowCycleDelay = 7;
/* TWR: min=1+ 7ns (1+1x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_WriteRecoveryTime = 2;
/* TRP: 20ns => 2x11.11ns */
FMC_SDRAMTimingInitStructure.FMC_RPDelay = 2;
/* TRCD: 20ns => 2x11.11ns */
FMC_SDRAMTimingInitStructure.FMC_RCDDelay = 2;
/* FMC SDRAM control configuration */
FMC_SDRAMInitStructure.FMC_Bank = FMC_Bank2_SDRAM;
/* Row addressing: [7:0] */
FMC_SDRAMInitStructure.FMC_ColumnBitsNumber = FMC_ColumnBits_Number_8b;
/* Column addressing: [11:0] */
FMC_SDRAMInitStructure.FMC_RowBitsNumber = FMC_RowBits_Number_12b;
FMC_SDRAMInitStructure.FMC_SDMemoryDataWidth = SDRAM_MEMORY_WIDTH;
FMC_SDRAMInitStructure.FMC_InternalBankNumber = FMC_InternalBank_Number_4;
FMC_SDRAMInitStructure.FMC_CASLatency = SDRAM_CAS_LATENCY;
FMC_SDRAMInitStructure.FMC_WriteProtection = FMC_Write_Protection_Disable;
FMC_SDRAMInitStructure.FMC_SDClockPeriod = SDCLOCK_PERIOD;
FMC_SDRAMInitStructure.FMC_ReadBurst = SDRAM_READBURST;
FMC_SDRAMInitStructure.FMC_ReadPipeDelay = FMC_ReadPipe_Delay_0;
FMC_SDRAMInitStructure.FMC_SDRAMTimingStruct = &FMC_SDRAMTimingInitStructure;
/* FMC SDRAM bank initialization */
FMC_SDRAMInit(&FMC_SDRAMInitStructure);
/* FMC SDRAM device initialization sequence */
SDRAMTest_InitSequence();
}
#if 0
void SDRAM_WriteBuffer(uint32_t* pBuffer, uint32_t uwWriteAddress, uint32_t uwBufferSize)
{
__IO uint32_t write_pointer = (uint32_t)uwWriteAddress;
FMC_SDRAMWriteProtectionConfig(FMC_Bank1_SDRAM, DISABLE);
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET)
{
}
for (; uwBufferSize != 0; uwBufferSize--)
{
*(uint32_t *) (SDRAM_BANK_ADDR + write_pointer) = *pBuffer++;
write_pointer += 4;
}
}
void SDRAM_ReadBuffer(uint32_t* pBuffer, uint32_t uwReadAddress, uint32_t uwBufferSize)
{
__IO uint32_t write_pointer = (uint32_t)uwReadAddress;
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET)
{
}
for(; uwBufferSize != 0x00; uwBufferSize--)
{
*pBuffer++ = *(__IO uint32_t *)(SDRAM_BANK_ADDR + write_pointer );
write_pointer += 4;
}
}
#endif
radio/src/targets/horus/tp_gt911.cpp
+12 -65
View File
@@ -19,6 +19,8 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_hal_ll.h"
#include "stm32_hal.h"
#include "stm32_i2c_driver.h"
@@ -38,12 +40,6 @@
#define TP_GT911_ID "911"
#define TPRST_LOW() LL_GPIO_ResetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN)
#define TPRST_HIGH() LL_GPIO_SetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN)
#define TPINT_LOW() LL_GPIO_ResetOutputPin(TOUCH_INT_GPIO, TOUCH_INT_GPIO_PIN)
#define TPINT_HIGH() LL_GPIO_SetOutputPin(TOUCH_INT_GPIO, TOUCH_INT_GPIO_PIN)
#if defined (RADIO_T18)
const uint8_t TOUCH_GT911_Cfg[] = {
GT911_CFG_NUMBER, // 0x8047 Config version
@@ -446,56 +442,6 @@ static void _gt911_exti_isr(void)
touchEventOccured = true;
}
static void TOUCH_AF_ExtiStop(void)
{
stm32_exti_disable(TOUCH_INT_EXTI_Line);
}
static void TOUCH_AF_ExtiConfig(void)
{
__HAL_RCC_SYSCFG_CLK_ENABLE();
LL_SYSCFG_SetEXTISource(TOUCH_INT_EXTI_Port, TOUCH_INT_EXTI_SysCfgLine);
stm32_exti_enable(TOUCH_INT_EXTI_Line,
LL_EXTI_TRIGGER_RISING,
_gt911_exti_isr);
}
static void TOUCH_AF_GPIOConfig(void)
{
LL_GPIO_InitTypeDef gpioInit;
LL_GPIO_StructInit(&gpioInit);
stm32_gpio_enable_clock(TOUCH_RST_GPIO);
stm32_gpio_enable_clock(TOUCH_INT_GPIO);
gpioInit.Mode = LL_GPIO_MODE_OUTPUT;
gpioInit.Speed = LL_GPIO_SPEED_FREQ_HIGH;
gpioInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
gpioInit.Pull = LL_GPIO_PULL_NO;
gpioInit.Pin = TOUCH_RST_GPIO_PIN;
LL_GPIO_Init(TOUCH_RST_GPIO, &gpioInit);
LL_GPIO_ResetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN);
gpioInit.Pin = TOUCH_INT_GPIO_PIN;
LL_GPIO_Init(TOUCH_INT_GPIO, &gpioInit);
LL_GPIO_ResetOutputPin(TOUCH_INT_GPIO, TOUCH_INT_GPIO_PIN);
}
void TOUCH_AF_INT_Change(void)
{
LL_GPIO_InitTypeDef gpioInit;
LL_GPIO_StructInit(&gpioInit);
gpioInit.Pin = TOUCH_INT_GPIO_PIN;
gpioInit.Mode = LL_GPIO_MODE_INPUT;
gpioInit.Speed = LL_GPIO_SPEED_FREQ_HIGH;
gpioInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
gpioInit.Pull = LL_GPIO_PULL_UP;
LL_GPIO_Init(TOUCH_INT_GPIO, &gpioInit);
}
void I2C_Init_Radio(void)
{
TRACE("GT911 I2C Init");
@@ -577,7 +523,7 @@ bool I2C_GT911_SendConfig(uint8_t cfgVer)
void touchPanelDeInit(void)
{
TOUCH_AF_ExtiStop();
gpio_int_disable(TOUCH_INT_GPIO);
touchGT911Flag = false;
}
@@ -588,25 +534,26 @@ bool touchPanelInit(void)
uint8_t tmp[4] = {0};
if (touchGT911Flag) {
TOUCH_AF_ExtiConfig();
gpio_init_int(TOUCH_INT_GPIO, GPIO_IN_PU, GPIO_RISING, _gt911_exti_isr);
return true;
} else {
TRACE("Touchpanel init start ...");
TOUCH_AF_GPIOConfig(); // SET RST=OUT INT=OUT INT=LOW
gpio_init(TOUCH_RST_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(TOUCH_INT_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
I2C_Init_Radio();
TPRST_LOW();
TPINT_HIGH();
gpio_clear(TOUCH_RST_GPIO);
gpio_set(TOUCH_INT_GPIO);
delay_us(200);
TPRST_HIGH();
gpio_set(TOUCH_RST_GPIO);
delay_ms(6);
TPINT_LOW();
gpio_clear(TOUCH_INT_GPIO);
delay_ms(55);
TOUCH_AF_INT_Change(); // Set INT INPUT INT=LOW
gpio_init(TOUCH_INT_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
delay_ms(50);
@@ -651,7 +598,7 @@ bool touchPanelInit(void)
}
touchGT911Flag = true;
TOUCH_AF_ExtiConfig();
gpio_init_int(TOUCH_INT_GPIO, GPIO_IN_PU, GPIO_RISING, _gt911_exti_isr);
return true;
}
radio/src/targets/horus/usb_charger_driver.cpp
+7 -11
View File
@@ -19,23 +19,19 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "board.h"
void usbChargerInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = USB_CHARGER_GPIO_PIN | USB_USBDet_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(USB_CHARGER_GPIO, &GPIO_InitStructure);
gpio_init(USB_CHARGER_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
gpio_init(USB_USBDet_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
}
bool usbChargerLed()
{
if (GPIO_ReadInputDataBit(USB_CHARGER_GPIO, USB_USBDet_GPIO_PIN) == 0)
return 0;
return GPIO_ReadInputDataBit(USB_CHARGER_GPIO, USB_CHARGER_GPIO_PIN) == Bit_RESET;
if (!gpio_read(USB_USBDet_GPIO)) return 0;
return !gpio_read(USB_CHARGER_GPIO);
}
radio/src/targets/nv14/CMakeLists.txt
+1 -1
View File
@@ -111,13 +111,13 @@ set(FIRMWARE_TARGET_SRC
board.cpp
${LCD_DRIVER}
${TOUCH_DRIVER}
sdram_driver.c
battery_driver.cpp
backlight_driver.cpp
)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/sdram_driver.cpp
targets/common/arm/stm32/dma2d.cpp
targets/common/arm/stm32/spi_flash.cpp
targets/common/arm/stm32/diskio_spi_flash.cpp
radio/src/targets/nv14/backlight_driver.cpp
+8 -18
View File
@@ -19,6 +19,10 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
#include "opentx_types.h"
#include "board.h"
@@ -27,30 +31,16 @@
void backlightLowInit( void )
{
RCC_AHB1PeriphClockCmd(BACKLIGHT_RCC_AHB1Periph, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_WriteBit( BACKLIGHT_GPIO, BACKLIGHT_GPIO_PIN, Bit_RESET );
gpio_init(BACKLIGHT_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_clear(BACKLIGHT_GPIO);
}
void backlightInit()
{
// PIN init
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource, BACKLIGHT_GPIO_AF);
gpio_init_af(BACKLIGHT_GPIO, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
// TODO review this when the timer will be chosen
stm32_timer_enable_clock(BACKLIGHT_TIMER);
BACKLIGHT_TIMER->ARR = 100;
BACKLIGHT_TIMER->PSC = BACKLIGHT_TIMER_FREQ / 1000000 - 1; // 10kHz (same as FrOS)
BACKLIGHT_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1PE; // PWM mode 1
radio/src/targets/nv14/battery_driver.cpp
+6 -8
View File
@@ -18,6 +18,10 @@
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "opentx.h"
#include "battery_driver.h"
@@ -35,14 +39,8 @@
void battery_charge_init()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = PWR_CHARGE_FINISHED_GPIO_PIN | PWR_CHARGING_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(PWR_CHARGING_GPIO, &GPIO_InitStructure);
GPIO_SetBits(PWR_CHARGING_GPIO, PWR_CHARGE_FINISHED_GPIO_PIN | PWR_CHARGING_GPIO_PIN);
gpio_init(PWR_CHARGE_FINISHED_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
gpio_init(PWR_CHARGING_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
}
#define CHARGE_SAMPLES 10
radio/src/targets/nv14/battery_driver.h
+4 -9
View File
@@ -39,16 +39,11 @@ enum ChargeState
};
#define PWR_CHARGE_FINISHED_GPIO GPIOB
#define PWR_CHARGE_FINISHED_GPIO_REG PWR_CHARGE_FINISHED_GPIO->IDR
#define PWR_CHARGE_FINISHED_GPIO_PIN GPIO_Pin_13 // PB.13
#define PWR_CHARGE_FINISHED_GPIO GPIO_PIN(GPIOB, 13) // PB.13
#define PWR_CHARGING_GPIO GPIO_PIN(GPIOB, 14) // PB.14
#define PWR_CHARGING_GPIO GPIOB
#define PWR_CHARGING_GPIO_REG PWR_CHARGING_GPIO->IDR
#define PWR_CHARGING_GPIO_PIN GPIO_Pin_14 // PB.14
#define READ_CHARGE_FINISHED_STATE() GPIO_ReadInputDataBit( PWR_CHARGE_FINISHED_GPIO, PWR_CHARGE_FINISHED_GPIO_PIN )
#define READ_CHARGING_STATE() GPIO_ReadInputDataBit( PWR_CHARGING_GPIO, PWR_CHARGING_GPIO_PIN )
#define READ_CHARGE_FINISHED_STATE() gpio_read(PWR_CHARGE_FINISHED_GPIO) ? 1 : 0
#define READ_CHARGING_STATE() gpio_read(PWR_CHARGING_GPIO) ? 1 : 0
extern void battery_charge_init();
extern void handle_battery_charge(uint32_t last_press_time);
radio/src/targets/nv14/board.cpp
+13 -57
View File
@@ -18,12 +18,14 @@
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "stm32_adc.h"
#include "stm32_gpio.h"
#include "board.h"
#include "boards/generic_stm32/module_ports.h"
#include "hal/gpio.h"
#include "hal/adc_driver.h"
#include "hal/trainer_driver.h"
#include "hal/switch_driver.h"
@@ -65,46 +67,16 @@ void delay_self(int count)
}
}
#define RCC_AHB1PeriphMinimum (PWR_RCC_AHB1Periph | \
LCD_RCC_AHB1Periph |\
BACKLIGHT_RCC_AHB1Periph |\
SDRAM_RCC_AHB1Periph \
)
#define RCC_AHB1PeriphOther (SD_RCC_AHB1Periph |\
AUDIO_RCC_AHB1Periph |\
MONITOR_RCC_AHB1Periph |\
TELEMETRY_RCC_AHB1Periph |\
AUDIO_RCC_AHB1Periph |\
HAPTIC_RCC_AHB1Periph |\
INTMODULE_RCC_AHB1Periph |\
EXTMODULE_RCC_AHB1Periph\
)
#define RCC_AHB3PeriphMinimum (SDRAM_RCC_AHB3Periph)
#define RCC_APB1PeriphMinimum (BACKLIGHT_RCC_APB1Periph)
#define RCC_APB1PeriphOther (TELEMETRY_RCC_APB1Periph)
#define RCC_AHB1PeriphMinimum (LCD_RCC_AHB1Periph)
#define RCC_APB2PeriphMinimum (LCD_RCC_APB2Periph)
#define RCC_APB2PeriphOther (HAPTIC_RCC_APB2Periph |\
AUDIO_RCC_APB2Periph \
)
static uint8_t boardGetPcbRev()
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_AHB1PeriphClockCmd(INTMODULE_RCC_AHB1Periph, ENABLE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = INTMODULE_PWR_GPIO_PIN;
GPIO_Init(INTMODULE_PWR_GPIO, &GPIO_InitStructure);
gpio_init(INTMODULE_PWR_GPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
delay_ms(1); // delay to let the input settle, else it does not work properly
// detect NV14 vs EL18
if (GPIO_ReadInputDataBit(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN) == Bit_SET) {
if (gpio_read(INTMODULE_PWR_GPIO)) {
// pull-up connected: EL18
return PCBREV_EL18;
} else {
@@ -115,15 +87,8 @@ static uint8_t boardGetPcbRev()
void boardBootloaderInit()
{
#if defined(USB_SW_PIN)
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = USB_SW_PIN;
GPIO_Init(USB_SW_GPOIO, &GPIO_InitStructure);
RCC_AHB1PeriphClockCmd(USB_SW_AHB1Periph_GPIO, ENABLE);
#if defined(USB_SW_GPIO)
gpio_init(USB_SW_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
// detect NV14 vs EL18
@@ -132,14 +97,7 @@ void boardBootloaderInit()
static void monitorInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_InitStructure.GPIO_Pin = VBUS_MONITOR_PIN;
GPIO_Init(GPIOJ, &GPIO_InitStructure);
gpio_init(VBUS_MONITOR_GPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
}
void boardInit()
@@ -149,10 +107,8 @@ void boardInit()
#endif
#if !defined(SIMU)
RCC_AHB1PeriphClockCmd(RCC_AHB1PeriphMinimum | RCC_AHB1PeriphOther, ENABLE);
RCC_AHB3PeriphClockCmd(RCC_AHB3PeriphMinimum, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1PeriphMinimum | RCC_APB1PeriphOther, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2PeriphMinimum | RCC_APB2PeriphOther, ENABLE);
LL_AHB1_GRP1_EnableClock(RCC_AHB1PeriphMinimum);
LL_APB2_GRP1_EnableClock(RCC_APB2PeriphMinimum);
// enable interrupts
__enable_irq();
@@ -235,13 +191,13 @@ void boardInit()
lcdSetInitalFrameBuffer(lcdFront->getData());
#if defined(DEBUG)
DBGMCU_APB1PeriphConfig(
/* DBGMCU_APB1PeriphConfig(
DBGMCU_IWDG_STOP | DBGMCU_TIM1_STOP | DBGMCU_TIM2_STOP |
DBGMCU_TIM3_STOP | DBGMCU_TIM4_STOP | DBGMCU_TIM5_STOP |
DBGMCU_TIM6_STOP | DBGMCU_TIM7_STOP | DBGMCU_TIM8_STOP |
DBGMCU_TIM9_STOP | DBGMCU_TIM10_STOP | DBGMCU_TIM11_STOP |
DBGMCU_TIM12_STOP | DBGMCU_TIM13_STOP | DBGMCU_TIM14_STOP,
ENABLE);
ENABLE);*/
#endif
}
radio/src/targets/nv14/board.h
+8 -11
View File
@@ -63,9 +63,6 @@ void flashWrite(uint32_t * address, const uint32_t * buffer);
uint32_t isFirmwareStart(const uint8_t * buffer);
uint32_t isBootloaderStart(const uint8_t * buffer);
// SDRAM driver
void SDRAM_Init();
enum {
PCBREV_NV14 = 0,
PCBREV_EL18 = 1,
@@ -82,24 +79,24 @@ extern HardwareOptions hardwareOptions;
#define INTERNAL_MODULE_OFF() \
do { \
if (hardwareOptions.pcbrev == PCBREV_NV14) \
GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN); \
gpio_set(INTMODULE_PWR_GPIO); \
else \
GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN); \
gpio_clear(INTMODULE_PWR_GPIO); \
} while (0)
#define INTERNAL_MODULE_ON() \
do { \
if (hardwareOptions.pcbrev == PCBREV_NV14) \
GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN); \
gpio_clear(INTMODULE_PWR_GPIO); \
else \
GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN); \
gpio_set(INTMODULE_PWR_GPIO); \
} while (0)
#define EXTERNAL_MODULE_ON() GPIO_SetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_OFF() GPIO_ResetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_ON() gpio_set(EXTMODULE_PWR_GPIO)
#define EXTERNAL_MODULE_OFF() gpio_clear(EXTMODULE_PWR_GPIO)
#define BLUETOOTH_MODULE_ON() GPIO_ResetBits(BT_EN_GPIO, BT_EN_GPIO_PIN)
#define BLUETOOTH_MODULE_OFF() GPIO_SetBits(BT_EN_GPIO, BT_EN_GPIO_PIN)
#define BLUETOOTH_MODULE_ON() gpio_clear(BLUETOOTH_ON_GPIO)
#define BLUETOOTH_MODULE_OFF() gpio_set(BLUETOOTH_ON_GPIO)
#else
radio/src/targets/nv14/bootloader/boot_menu.cpp
+7 -4
View File
@@ -19,21 +19,24 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "board.h"
#include "fw_version.h"
#include "lcd.h"
#include "translations.h"
#include "../../common/arm/stm32/bootloader/boot.h"
#include "../../common/arm/stm32/bootloader/bin_files.h"
#include "targets/common/arm/stm32/bootloader/boot.h"
#include "targets/common/arm/stm32/bootloader/bin_files.h"
#include <lvgl/lvgl.h>
#define RADIO_MENU_LEN 2
#define USB_SW_TO_INTERNAL_MODULE() GPIO_SetBits(USB_SW_GPOIO, USB_SW_PIN);
#define USB_SW_TO_MCU() GPIO_ResetBits(USB_SW_GPOIO, USB_SW_PIN);
#define USB_SW_TO_INTERNAL_MODULE() gpio_set(USB_SW_GPIO);
#define USB_SW_TO_MCU() gpio_clear(USB_SW_GPIO);
#define DEFAULT_PADDING 28
#define DOUBLE_PADDING 56
radio/src/targets/nv14/hal.h
+65 -168
View File
@@ -74,9 +74,7 @@
#define KEYS_GPIO_PIN_EXIT LL_GPIO_PIN_11 // PG.11
// Monitor pin
#define MONITOR_RCC_AHB1Periph (RCC_AHB1Periph_GPIOJ)
#define VBUS_MONITOR_GPIO (GPIOJ)
#define VBUS_MONITOR_PIN (GPIO_Pin_14)
#define VBUS_MONITOR_GPIO GPIO_PIN(GPIOJ, 14) // PJ.14
// Switches
#define HARDWARE_SWITCH_A
@@ -174,11 +172,8 @@
}
// Power
#define PWR_RCC_AHB1Periph RCC_AHB1Periph_GPIOI
#define PWR_ON_GPIO GPIOI
#define PWR_SWITCH_GPIO GPIOI
#define PWR_SWITCH_GPIO_PIN GPIO_Pin_11 // PI.11
#define PWR_ON_GPIO_PIN GPIO_Pin_14 // PI.14
#define PWR_SWITCH_GPIO GPIO_PIN(GPIOI, 11) // PI.11
#define PWR_ON_GPIO GPIO_PIN(GPIOI, 14) // PI.14
// S.Port update connector
#define SPORT_MAX_BAUDRATE 400000
@@ -215,38 +210,21 @@
#define KEYS_BACKLIGHT_RCC_AHB1Periph 0
// Telemetry
#define TELEMETRY_RCC_AHB1Periph (RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOJ | RCC_AHB1Periph_DMA1)
#define TELEMETRY_RCC_APB1Periph RCC_APB1Periph_USART2
#define TELEMETRY_REV_GPIO GPIOJ
#define TELEMETRY_RX_REV_GPIO_PIN GPIO_Pin_8 // PJ.08
#define TELEMETRY_TX_REV_GPIO_PIN GPIO_Pin_7 // PJ.07
#define TELEMETRY_DIR_GPIO GPIOJ
#define TELEMETRY_DIR_GPIO_PIN GPIO_Pin_13 // PJ.13
#define TELEMETRY_RX_REV_GPIO GPIO_PIN(GPIOJ, 8) // PJ.08
#define TELEMETRY_TX_REV_GPIO GPIO_PIN(GPIOJ, 7) // PJ.07
#define TELEMETRY_DIR_GPIO GPIO_PIN(GPIOJ, 13) // PJ.13
#define TELEMETRY_SET_INPUT 1
#define TELEMETRY_GPIO GPIOD
#define TELEMETRY_TX_GPIO_PIN GPIO_Pin_5 // PD.05
#define TELEMETRY_RX_GPIO_PIN GPIO_Pin_6 // PD.06
#define TELEMETRY_GPIO_PinSource_TX GPIO_PinSource5
#define TELEMETRY_GPIO_PinSource_RX GPIO_PinSource6
#define TELEMETRY_GPIO_AF GPIO_AF_USART2
#define TELEMETRY_TX_GPIO GPIO_PIN(GPIOD, 5) // PD.05
#define TELEMETRY_RX_GPIO GPIO_PIN(GPIOD, 6) // PD.06
#define TELEMETRY_USART USART2
#define TELEMETRY_USART_IRQn USART2_IRQn
#define TELEMETRY_DMA DMA1
#define TELEMETRY_DMA_Stream_TX LL_DMA_STREAM_6
#define TELEMETRY_DMA_Channel_TX DMA_Channel_4
#define TELEMETRY_DMA_Channel_TX LL_DMA_CHANNEL_4
#define TELEMETRY_DMA_TX_Stream_IRQ DMA1_Stream6_IRQn
#define TELEMETRY_DMA_TX_IRQHandler DMA1_Stream6_IRQHandler
#define TELEMETRY_DMA_TX_FLAG_TC DMA_IT_TCIF6
// #define TELEMETRY_DMA_Stream_RX LL_DMA_STREAM_5
// #define TELEMETRY_DMA_Channel_RX LL_DMA_CHANNEL_4
#define TELEMETRY_USART_IRQHandler USART2_IRQHandler
#define TELEMETRY_USART_IRQn USART2_IRQn
#define TELEMETRY_DIR_OUTPUT() TELEMETRY_DIR_GPIO->BSRRH = TELEMETRY_DIR_GPIO_PIN
#define TELEMETRY_DIR_INPUT() TELEMETRY_DIR_GPIO->BSRRL = TELEMETRY_DIR_GPIO_PIN
#define TELEMETRY_TX_POL_NORM() TELEMETRY_REV_GPIO->BSRRH = TELEMETRY_TX_REV_GPIO_PIN
#define TELEMETRY_TX_POL_INV() TELEMETRY_REV_GPIO->BSRRL = TELEMETRY_TX_REV_GPIO_PIN
#define TELEMETRY_RX_POL_NORM() TELEMETRY_REV_GPIO->BSRRH = TELEMETRY_RX_REV_GPIO_PIN
#define TELEMETRY_RX_POL_INV() TELEMETRY_REV_GPIO->BSRRL = TELEMETRY_RX_REV_GPIO_PIN
// Software IRQ (Prio 5 -> FreeRTOS compatible)
#define TELEMETRY_RX_FRAME_EXTI_LINE LL_EXTI_LINE_4
@@ -256,39 +234,28 @@
// USB
#define USB_RCC_AHB1Periph_GPIO RCC_AHB1Periph_GPIOA
#define USB_GPIO GPIOA
#define USB_GPIO_PIN_VBUS LL_GPIO_PIN_9 // PA.09
#define USB_GPIO_PIN_DM LL_GPIO_PIN_11 // PA.11
#define USB_GPIO_PIN_DP LL_GPIO_PIN_12 // PA.12
#define USB_GPIO_AF GPIO_AF_OTG1_FS
#define USB_SW_AHB1Periph_GPIO RCC_AHB1Periph_GPIOI
#define USB_SW_GPOIO GPIOI
#define USB_SW_PIN GPIO_Pin_10
#define USB_GPIO_VBUS GPIO_PIN(GPIOA,9) // PA.09
#define USB_GPIO_DM GPIO_PIN(GPIOA, 11) // PA.11
#define USB_GPIO_DP GPIO_PIN(GPIOA, 12) // PA.12
#define USB_GPIO_AF GPIO_AF10
#define USB_SW_GPIO GPIO_PIN(GPIOI, 10) // PI.10
// LCD
#define LCD_RCC_AHB1Periph (RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_GPIOJ | RCC_AHB1Periph_GPIOK | RCC_AHB1Periph_DMA2D)
#define LCD_RCC_APB1Periph 0
#define LCD_RCC_APB2Periph RCC_APB2Periph_LTDC
#define LCD_NRST_GPIO GPIOG
#define LCD_NRST_GPIO_PIN LL_GPIO_PIN_9 // PG.09
#define LCD_SPI_GPIO GPIOE
#define LCD_SPI_CS_GPIO_PIN LL_GPIO_PIN_4 // PE.04
#define LCD_SPI_SCK_GPIO_PIN LL_GPIO_PIN_2 // PE.02
#define LCD_SPI_MISO_GPIO_PIN LL_GPIO_PIN_5 // PE.05
#define LCD_SPI_MOSI_GPIO_PIN LL_GPIO_PIN_6 // PE.06
#define LCD_RCC_AHB1Periph LL_AHB1_GRP1_PERIPH_DMA2D
#define LCD_RCC_APB2Periph LL_APB2_GRP1_PERIPH_LTDC
#define LCD_NRST_GPIO GPIO_PIN(GPIOG, 9) // PG.09
#define LCD_SPI_CS_GPIO GPIO_PIN(GPIOE, 4) // PE.04
#define LCD_SPI_SCK_GPIO GPIO_PIN(GPIOE, 2) // PE.02
#define LCD_SPI_MISO_GPIO GPIO_PIN(GPIOE, 5) // PE.05
#define LCD_SPI_MOSI_GPIO GPIO_PIN(GPIOE, 6) // PE.06
#define LTDC_IRQ_PRIO 4
#define DMA_SCREEN_IRQ_PRIO 6
// Backlight
// TODO TIM3, TIM8, TIM14, review the channel in backlight_driver.cpp according to the chosen timer
#define BACKLIGHT_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define BACKLIGHT_RCC_APB1Periph RCC_APB1Periph_TIM2
#define BACKLIGHT_RCC_APB2Periph 0
#define BACKLIGHT_GPIO GPIOA
#define BACKLIGHT_GPIO_PIN GPIO_Pin_15
#define BACKLIGHT_GPIO_PinSource GPIO_PinSource15
#define BACKLIGHT_GPIO GPIO_PIN(GPIOA, 15) // PA.15
#define BACKLIGHT_TIMER TIM2
#define BACKLIGHT_GPIO_AF GPIO_AF_TIM2
#define BACKLIGHT_GPIO_AF GPIO_AF1
#define BACKLIGHT_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
//used in BOOTLOADER
@@ -297,11 +264,7 @@
#define ROTARY_ENCODER_RCC_APB1Periph 0
// SD card
#define SD_RCC_AHB1Periph (RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOH | RCC_AHB1Periph_DMA2)
#define SD_RCC_APB1Periph 0
#define SD_PRESENT_GPIO GPIOH
#define SD_PRESENT_GPIO_PIN GPIO_Pin_10 // PH.10
#define SD_PRESENT_LL_GPIO_PIN LL_GPIO_PIN_10 // PH.10
#define SD_PRESENT_GPIO GPIO_PIN(GPIOH, 10) // PH.10
#define SD_SDIO_DMA DMA2
#define SD_SDIO_DMA_STREAM DMA2_Stream3
#define SD_SDIO_DMA_CHANNEL LL_DMA_CHANNEL_4
@@ -325,10 +288,6 @@
#define FLASH_SPI_DMA_TX_STREAM LL_DMA_STREAM_5
#define FLASH_SPI_DMA_RX_STREAM LL_DMA_STREAM_6
// SDRAM
#define SDRAM_RCC_AHB1Periph (RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_GPIOF | RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_GPIOH)
#define SDRAM_RCC_AHB3Periph RCC_AHB3Periph_FMC
// SPI FLASH
#define EEPROM_RCC_AHB1Periph RCC_AHB1Periph_GPIOG
#define EEPROM_RCC_APB1Periph RCC_APB1Periph_SPI6
@@ -345,29 +304,23 @@
#define EEPROM_SPI_MOSI_GPIO_PinSource GPIO_PinSource14
// Audio
#define AUDIO_RCC_AHB1Periph (RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOH)
#define AUDIO_RCC_APB2Periph RCC_APB2Periph_SPI1
#define AUDIO_XDCS_GPIO GPIOH
#define AUDIO_XDCS_GPIO_PIN GPIO_Pin_14 // PH.14
#define AUDIO_XDCS_GPIO_PIN LL_GPIO_PIN_14 // PH.14
#define AUDIO_CS_GPIO GPIOH
#define AUDIO_CS_GPIO_PIN GPIO_Pin_13 // PH.13
#define AUDIO_CS_GPIO_PIN LL_GPIO_PIN_13 // PH.13
#define AUDIO_DREQ_GPIO GPIOH
#define AUDIO_DREQ_GPIO_PIN GPIO_Pin_15 // PH.15
#define AUDIO_DREQ_GPIO_PIN LL_GPIO_PIN_15 // PH.15
#define AUDIO_RST_GPIO GPIOD
#define AUDIO_RST_GPIO_PIN GPIO_Pin_4 // PD.4
#define AUDIO_RST_GPIO_PIN LL_GPIO_PIN_4 // PD.04
#define AUDIO_SPI SPI1
#define AUDIO_SPI_GPIO_AF GPIO_AF_SPI1
#define AUDIO_SPI_GPIO_AF LL_GPIO_AF_5
#define AUDIO_SPI_SCK_GPIO GPIOB
#define AUDIO_SPI_SCK_GPIO_PIN GPIO_Pin_3 // PB.03
#define AUDIO_SPI_SCK_GPIO_PinSource GPIO_PinSource3
#define AUDIO_SPI_SCK_GPIO_PIN LL_GPIO_PIN_3 // PB.03
#define AUDIO_SPI_MISO_GPIO GPIOB
#define AUDIO_SPI_MISO_GPIO_PIN GPIO_Pin_4 // PB.04
#define AUDIO_SPI_MISO_GPIO_PinSource GPIO_PinSource4
#define AUDIO_SPI_MISO_GPIO_PIN LL_GPIO_PIN_4 // PB.04
#define AUDIO_SPI_MOSI_GPIO GPIOB
#define AUDIO_SPI_MOSI_GPIO_PIN GPIO_Pin_5 // PB.05
#define AUDIO_SPI_MOSI_GPIO_PinSource GPIO_PinSource5
#define AUDIO_MUTE_GPIO GPIOH
#define AUDIO_MUTE_GPIO_PIN GPIO_Pin_8 // PH.08 audio amp control pin
#define AUDIO_SPI_MOSI_GPIO_PIN LL_GPIO_PIN_5 // PB.05
#define AUDIO_MUTE_GPIO GPIO_PIN(GPIOH, 8) // PH.08 audio amp control pin
#define AUDIO_UNMUTE_DELAY 120 // ms
#define AUDIO_MUTE_DELAY 500 // ms
#define INVERTED_MUTE_PIN
@@ -383,11 +336,8 @@
#define TOUCH_I2C_BUS I2C_Bus_1
#define TOUCH_I2C_CLK_RATE 400000
#define TOUCH_INT_GPIO GPIOB
#define TOUCH_INT_GPIO_PIN LL_GPIO_PIN_9 // PB.09
#define TOUCH_RST_GPIO GPIOB
#define TOUCH_RST_GPIO_PIN LL_GPIO_PIN_12 // PB.12
#define TOUCH_INT_GPIO GPIO_PIN(GPIOB, 9) // PB.09
#define TOUCH_RST_GPIO GPIO_PIN(GPIOB, 12) // PB.12
#define TOUCH_INT_EXTI_Line LL_EXTI_LINE_9
#define TOUCH_INT_EXTI_Port LL_SYSCFG_EXTI_PORTB
@@ -401,46 +351,32 @@
// Haptic: TIM1_CH1
#define HAPTIC_PWM
#define HAPTIC_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define HAPTIC_RCC_APB2Periph RCC_APB2ENR_TIM1EN
#define HAPTIC_GPIO GPIOA
#define HAPTIC_GPIO_PIN GPIO_Pin_8
#define HAPTIC_GPIO GPIO_PIN(GPIOA, 8) // PA.08
#define HAPTIC_GPIO_TIMER TIM1
#define HAPTIC_GPIO_AF GPIO_AF_TIM1
#define HAPTIC_GPIO_PinSource GPIO_PinSource8
#define HAPTIC_GPIO_AF GPIO_AF1
#define HAPTIC_TIMER_OUTPUT_ENABLE TIM_CCER_CC1E | TIM_CCER_CC1NE;
#define HAPTIC_TIMER_MODE TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1PE
#define HAPTIC_TIMER_COMPARE_VALUE HAPTIC_GPIO_TIMER->CCR1
// Flysky Hall Stick
#define FLYSKY_HALL_SERIAL_USART UART4
#define FLYSKY_HALL_SERIAL_GPIO GPIOA
#define FLYSKY_HALL_DMA_Channel LL_DMA_CHANNEL_4
#define FLYSKY_HALL_SERIAL_TX_GPIO_PIN LL_GPIO_PIN_0 // PA.00
#define FLYSKY_HALL_SERIAL_RX_GPIO_PIN LL_GPIO_PIN_1 // PA.01
#define FLYSKY_HALL_SERIAL_GPIO_AF LL_GPIO_AF_8
#define FLYSKY_HALL_SERIAL_USART_IRQHandler UART4_IRQHandler
#define FLYSKY_HALL_SERIAL_TX_GPIO GPIO_PIN(GPIOA, 0) // PA.00
#define FLYSKY_HALL_SERIAL_RX_GPIO GPIO_PIN(GPIOA, 1) // PA.01
#define FLYSKY_HALL_SERIAL_USART_IRQn UART4_IRQn
#define FLYSKY_HALL_SERIAL_DMA DMA1
#define FLYSKY_HALL_DMA_Stream_RX LL_DMA_STREAM_2
#define FLYSKY_HALL_DMA_Stream_TX LL_DMA_STREAM_4
// Internal Module
#define INTMODULE_RCC_AHB1Periph (RCC_AHB1Periph_GPIOF | RCC_AHB1Periph_GPIOH | RCC_AHB1Periph_DMA1)
#define INTMODULE_PWR_GPIO GPIOH
#define INTMODULE_PWR_GPIO_PIN GPIO_Pin_9 // PH.09
#define INTMODULE_GPIO GPIOF
#define INTMODULE_TX_GPIO_PIN LL_GPIO_PIN_7 // PF.07
#define INTMODULE_RX_GPIO_PIN LL_GPIO_PIN_6 // PF.06
#define INTMODULE_PWR_GPIO GPIO_PIN(GPIOH, 9) // PH.09
#define INTMODULE_TX_GPIO GPIO_PIN(GPIOF, 7) // PF.07
#define INTMODULE_RX_GPIO GPIO_PIN(GPIOF, 6) // PF.06
#define INTMODULE_USART UART7
#define INTMODULE_GPIO_AF GPIO_AF_UART7
#define INTMODULE_GPIO_AF_LL LL_GPIO_AF_8
#define INTMODULE_USART_IRQn UART7_IRQn
#define INTMODULE_USART_IRQHandler UART7_IRQHandler
#define INTMODULE_DMA DMA1
#define INTMODULE_DMA_STREAM LL_DMA_STREAM_1
#define INTMODULE_DMA_STREAM_IRQ DMA1_Stream1_IRQn
#define INTMODULE_DMA_FLAG_TC DMA_IT_TCIF1
#define INTMODULE_DMA_CHANNEL LL_DMA_CHANNEL_5
#define INTMODULE_RX_DMA DMA1
@@ -458,26 +394,16 @@
// External Module
#define EXTMODULE
#define EXTMODULE_PULSES
#define EXTMODULE_PWR_GPIO GPIOD
#define EXTMODULE_PWR_GPIO_PIN GPIO_Pin_11
#define EXTMODULE_PWR_FIX_GPIO GPIOA
#define EXTMODULE_PWR_FIX_GPIO_PIN GPIO_Pin_2 // PA.02
#define EXTMODULE_RCC_AHB1Periph \
(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOC | \
RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_DMA2)
#define EXTMODULE_TX_GPIO GPIOC
#define EXTMODULE_TX_GPIO_PIN LL_GPIO_PIN_6 // PC.06
#define EXTMODULE_TX_GPIO_AF LL_GPIO_AF_3 // TIM8_CH1
#define EXTMODULE_TX_GPIO_AF_USART GPIO_AF_USART6
#define EXTMODULE_RX_GPIO GPIOC
#define EXTMODULE_RX_GPIO_PIN LL_GPIO_PIN_7 // PC.07
#define EXTMODULE_RX_GPIO_AF_USART GPIO_AF_USART6
#define EXTMODULE_PWR_GPIO GPIO_PIN(GPIOD, 11) // PD.11
#define EXTMODULE_PWR_FIX_GPIO GPIO_PIN(GPIOA, 2) // PA.02
#define EXTMODULE_TX_GPIO GPIO_PIN(GPIOC, 6) // PC.06
#define EXTMODULE_RX_GPIO GPIO_PIN(GPIOC, 7) // PC.07
#define EXTMODULE_TIMER TIM8
#define EXTMODULE_TIMER_TX_GPIO_AF LL_GPIO_AF_3 // TIM8_CH1
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH1
#define EXTMODULE_TIMER_IRQn TIM8_UP_TIM13_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM8_UP_TIM13_IRQHandler
#define EXTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#define EXTMODULE_TIMER_TX_GPIO_AF LL_GPIO_AF_3
//USART
#define EXTMODULE_USART USART6
#define EXTMODULE_USART_GPIO GPIOC
@@ -485,46 +411,28 @@
#define EXTMODULE_USART_GPIO_AF_LL LL_GPIO_AF_8
#define EXTMODULE_USART_TX_DMA DMA2
#define EXTMODULE_USART_TX_DMA_CHANNEL LL_DMA_CHANNEL_5
#define EXTMODULE_USART_TX_DMA_STREAM DMA2_Stream7
#define EXTMODULE_USART_TX_DMA_STREAM_LL LL_DMA_STREAM_7
#define EXTMODULE_USART_TX_DMA_STREAM LL_DMA_STREAM_7
#define EXTMODULE_USART_RX_DMA_CHANNEL LL_DMA_CHANNEL_5
#define EXTMODULE_USART_RX_DMA_STREAM DMA2_Stream2
#define EXTMODULE_USART_RX_DMA_STREAM_LL LL_DMA_STREAM_2
#define EXTMODULE_USART_IRQHandler USART6_IRQHandler
#define EXTMODULE_USART_RX_DMA_STREAM LL_DMA_STREAM_2
#define EXTMODULE_USART_IRQn USART6_IRQn
//TIMER
#define EXTMODULE_TIMER_DMA_CHANNEL LL_DMA_CHANNEL_7
#define EXTMODULE_TIMER_DMA_STREAM DMA2_Stream1
#define EXTMODULE_TIMER_DMA DMA2
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_CHANNEL LL_DMA_CHANNEL_7
#define EXTMODULE_TIMER_DMA_STREAM LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream1_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA2_Stream1_IRQHandler
#define EXTMODULE_TX_INVERT_GPIO GPIOE
#define EXTMODULE_TX_INVERT_GPIO_PIN GPIO_Pin_3 // PE.03
#define EXTMODULE_RX_INVERT_GPIO GPIOI
#define EXTMODULE_RX_INVERT_GPIO_PIN GPIO_Pin_15 // PI.15
#define EXTMODULE_TX_NORMAL() EXTMODULE_TX_INVERT_GPIO->BSRRH = EXTMODULE_TX_INVERT_GPIO_PIN
#define EXTMODULE_TX_INVERTED() EXTMODULE_TX_INVERT_GPIO->BSRRL = EXTMODULE_TX_INVERT_GPIO_PIN
#define EXTMODULE_RX_NORMAL() EXTMODULE_RX_INVERT_GPIO->BSRRH = EXTMODULE_RX_INVERT_GPIO_PIN
#define EXTMODULE_RX_INVERTED() EXTMODULE_RX_INVERT_GPIO->BSRRL = EXTMODULE_RX_INVERT_GPIO_PIN
// Heartbeat (not used)
#define HEARTBEAT_RCC_AHB1Periph RCC_AHB1Periph_GPIOD
#define HEARTBEAT_GPIO GPIOD
#define HEARTBEAT_GPIO_PIN GPIO_Pin_12 // PD.12
#define EXTMODULE_TX_INVERT_GPIO GPIO_PIN(GPIOE, 3) // PE.03
#define EXTMODULE_RX_INVERT_GPIO GPIO_PIN(GPIOI, 15) // PI.15
// Trainer Port
#define TRAINER_GPIO GPIOD
#define TRAINER_IN_GPIO_PIN LL_GPIO_PIN_12 // PD.12
#define TRAINER_IN_GPIO GPIO_PIN(GPIOD, 12) // PD.12
#define TRAINER_IN_TIMER_Channel LL_TIM_CHANNEL_CH1
#define TRAINER_OUT_GPIO_PIN LL_GPIO_PIN_13 // PD.13
#define TRAINER_OUT_GPIO GPIO_PIN(GPIOD, 13) // PD.13
#define TRAINER_OUT_TIMER_Channel LL_TIM_CHANNEL_CH2
#define TRAINER_TIMER TIM4
@@ -532,33 +440,19 @@
#define TRAINER_TIMER_IRQHandler TIM4_IRQHandler
#define TRAINER_GPIO_AF LL_GPIO_AF_2
#define TRAINER_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
//ROTARY emulation for trims as buttons
#define ROTARY_ENCODER_NAVIGATION
// Bluetooth
#define BT_RCC_AHB1Periph (RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_GPIOH)
#define BT_RCC_APB1Periph (RCC_APB1Periph_USART3)
#define BT_RCC_APB2Periph 0
#define BLUETOOTH_ON_GPIO GPIO_PIN(GPIOI, 8) // PI.8
#define BT_USART USART3
#define BT_GPIO_AF GPIO_AF_USART3
#define BT_USART_IRQn USART3_IRQn
#define BT_GPIO_TXRX GPIOB
#define BT_TX_GPIO_PIN GPIO_Pin_10 // PB.10
#define BT_RX_GPIO_PIN GPIO_Pin_11 // PB.11
#define BT_TX_GPIO_PinSource GPIO_PinSource10
#define BT_RX_GPIO_PinSource GPIO_PinSource11
#define BT_USART_IRQHandler USART3_IRQHandler
#define BT_EN_GPIO GPIOI
#define BT_EN_GPIO_PIN GPIO_Pin_8 // PI.08
#define BT_CONNECTED_GPIO GPIOJ
#define BT_CONNECTED_GPIO_PIN GPIO_Pin_1 // PJ.10
#define BT_CMD_MODE_GPIO GPIOH
#define BT_CMD_MODE_GPIO_PIN GPIO_Pin_6 // PH.6
#define BT_TX_GPIO GPIO_PIN(GPIOB, 10) // PB.10
#define BT_RX_GPIO GPIO_PIN(GPIOB, 11) // PB.11
#define BT_EN_GPIO GPIO_PIN(GPIOI, 8) // PI.08
#define BT_CONNECTED_GPIO GPIO_PIN(GPIOJ, 10) // PJ.10
#define BT_CMD_MODE_GPIO GPIO_PIN(GPIOH, 6) // PH.06
// Millisecond timer
#define MS_TIMER TIM14
@@ -571,6 +465,9 @@
#define MIXER_SCHEDULER_TIMER_IRQn TIM8_BRK_TIM12_IRQn
#define MIXER_SCHEDULER_TIMER_IRQHandler TIM8_BRK_TIM12_IRQHandler
// SDRAM
#define SDRAM_BANK1
#define LCD_W 320
#define LCD_H 480
radio/src/targets/nv14/haptic_driver.cpp
+6 -10
View File
@@ -19,6 +19,10 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
#include "board.h"
void hapticOff(void)
@@ -36,16 +40,9 @@ void hapticOn(uint32_t pwmPercent)
void hapticInit(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = HAPTIC_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(HAPTIC_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(HAPTIC_GPIO, HAPTIC_GPIO_PinSource, HAPTIC_GPIO_AF);
gpio_init_af(HAPTIC_GPIO, HAPTIC_GPIO_AF, GPIO_PIN_SPEED_LOW);
stm32_timer_enable_clock(HAPTIC_GPIO_TIMER);
HAPTIC_GPIO_TIMER->ARR = 100;
HAPTIC_GPIO_TIMER->PSC = (PERI2_FREQUENCY * TIMER_MULT_APB2) / 10000 - 1;
HAPTIC_GPIO_TIMER->CCMR1 = HAPTIC_TIMER_MODE; // PWM
@@ -59,5 +56,4 @@ void hapticInit(void)
void hapticDone(void)
{
hapticOff();
RCC_AHB1PeriphClockCmd(HAPTIC_RCC_AHB1Periph, DISABLE);
}
radio/src/targets/nv14/lcd_driver.cpp
+64 -62
View File
@@ -21,9 +21,12 @@
#include "stm32_hal_ll.h"
#include "stm32_hal.h"
#include "opentx_types.h"
#include "dma2d.h"
#include "hal.h"
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "delays_driver.h"
#include "debug.h"
#include "lcd.h"
@@ -32,6 +35,8 @@
static LTDC_HandleTypeDef hltdc;
static void* initialFrameBuffer = nullptr;
#define GPIO_AF_LTDC GPIO_AF14
static volatile uint8_t _frame_addr_reloaded = 0;
static void startLcdRefresh(lv_disp_drv_t *disp_drv, uint16_t *buffer,
@@ -83,67 +88,64 @@ enum ENUM_IO_MODE
IO_MODE_ANALOG
};
static void LCD_AF_GPIOConfig(void) {
LL_GPIO_InitTypeDef GPIO_InitStructure;
LL_GPIO_StructInit(&GPIO_InitStructure);
static void LCD_AF_GPIOConfig(void)
{
/* GPIOs Configuration */
/*
-----------------------------------------------------------------------------
LCD_CLK <-> PG.07 | LCD_HSYNC <-> PI.12 | LCD_R3 <-> PJ.02 | LCD_G5 <-> PK.00
| LCD VSYNC <-> PI.13 | LCD_R4 <-> PJ.03 | LCD_G6 <-> PK.01
| | LCD_R5 <-> PJ.04 | LCD_G7 <-> PK.02
| | LCD_R6 <-> PJ.05 | LCD_B4 <-> PK.03
| | LCD_R7 <-> PJ.06 | LCD_B5 <-> PK.04
| | LCD_G2 <-> PJ.09 | LCD_B6 <-> PK.05
| | LCD_G3 <-> PJ.10 | LCD_B7 <-> PK.06
| | LCD_G4 <-> PJ.11 | LCD_DE <-> PK.07
| | LCD_B3 <-> PJ.15 |
*/
+---------------------+---------------------+------------------+------------------+
+ LCD pins assignment +
+---------------------+---------------------+------------------+------------------+
| LCD_CLK <-> PG.07 | LCD_HSYNC <-> PI.12 | LCD_R3 <-> PJ.02 | LCD_G5 <-> PK.00 |
| LCD VSYNC <-> PI.13 | LCD_R4 <-> PJ.03 | LCD_G6 <-> PK.01 | |
| | LCD_R5 <-> PJ.04 | LCD_G7 <-> PK.02 | |
| | LCD_R6 <-> PJ.05 | LCD_B4 <-> PK.03 | |
| | LCD_R7 <-> PJ.06 | LCD_B5 <-> PK.04 | |
| | LCD_G2 <-> PJ.09 | LCD_B6 <-> PK.05 | |
| | LCD_G3 <-> PJ.10 | LCD_B7 <-> PK.06 | |
| | LCD_G4 <-> PJ.11 | LCD_DE <-> PK.07 | |
| | LCD_B3 <-> PJ.15 | | |
+---------------------+---------------------+------------------+------------------+
*/
// GPIOG configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_7;
GPIO_InitStructure.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStructure.Mode = LL_GPIO_MODE_ALTERNATE;
GPIO_InitStructure.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStructure.Pull = LL_GPIO_PULL_NO;
GPIO_InitStructure.Alternate = LL_GPIO_AF_14; // AF LTDC
LL_GPIO_Init(GPIOG, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOG, 7), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
// GPIOI configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_12 | LL_GPIO_PIN_13;
LL_GPIO_Init(GPIOI, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOI, 12), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOI, 13), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
// GPIOJ configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_2 | LL_GPIO_PIN_3 | LL_GPIO_PIN_4 | LL_GPIO_PIN_5 | LL_GPIO_PIN_6 | LL_GPIO_PIN_9 | LL_GPIO_PIN_10 | LL_GPIO_PIN_11 | LL_GPIO_PIN_15;
LL_GPIO_Init(GPIOJ, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOJ, 2), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 3), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 4), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 5), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 6), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 9), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 10), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 11), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 15), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
// GPIOK configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_0 | LL_GPIO_PIN_1 | LL_GPIO_PIN_2 | LL_GPIO_PIN_3 | LL_GPIO_PIN_4 | LL_GPIO_PIN_5 | LL_GPIO_PIN_6 | LL_GPIO_PIN_7;
LL_GPIO_Init(GPIOK, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOK, 0), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 1), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 2), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 3), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 4), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 5), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 6), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 7), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
}
static void lcdSpiConfig(void) {
LL_GPIO_InitTypeDef GPIO_InitStructure;
LL_GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.Pin = LCD_SPI_SCK_GPIO_PIN | LCD_SPI_MOSI_GPIO_PIN;
GPIO_InitStructure.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStructure.Mode = LL_GPIO_MODE_OUTPUT;
GPIO_InitStructure.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStructure.Pull = LL_GPIO_PULL_NO;
LL_GPIO_Init(LCD_SPI_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.Pin = LCD_SPI_CS_GPIO_PIN;
GPIO_InitStructure.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStructure.Mode = LL_GPIO_MODE_OUTPUT;
GPIO_InitStructure.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStructure.Pull = LL_GPIO_PULL_UP;
LL_GPIO_Init(LCD_SPI_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.Pin = LCD_NRST_GPIO_PIN;
LL_GPIO_Init(LCD_NRST_GPIO, &GPIO_InitStructure);
static void lcdSpiConfig(void)
{
gpio_init(LCD_SPI_SCK_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_SPI_MOSI_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_SPI_CS_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_NRST_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
/* Set the chip select pin aways low */
LCD_CS_LOW();
CLR_LCD_CS();
}
void lcdDelay() {
@@ -154,25 +156,25 @@ unsigned char LCD_ReadByteOnFallingEdge(void) {
unsigned int i;
unsigned char ReceiveData = 0;
LCD_MOSI_HIGH();
LCD_MOSI_AS_INPUT();
SET_LCD_DATA();
SET_LCD_DATA_INPUT();
for (i = 0; i < 8; i++) {
LCD_DELAY();
LCD_SCK_HIGH();
SET_LCD_CLK();
LCD_DELAY();
LCD_DELAY();
ReceiveData <<= 1;
LCD_SCK_LOW();
CLR_LCD_CLK();
LCD_DELAY();
LCD_DELAY();
if (LCD_READ_DATA_PIN()) {
if (READ_LCD_DATA_PIN()) {
ReceiveData |= 0x01;
}
}
LCD_MOSI_AS_OUTPUT();
SET_LCD_DATA_OUTPUT();
return (ReceiveData);
}
@@ -213,22 +215,22 @@ unsigned char LCD_ReadByte(void) {
unsigned int i;
unsigned char ReceiveData = 0;
LCD_MOSI_HIGH();
LCD_MOSI_AS_INPUT();
SET_LCD_DATA();
SET_LCD_DATA_INPUT();
for (i = 0; i < 8; i++) {
LCD_SCK_LOW();
CLR_LCD_CLK();
LCD_DELAY();
LCD_DELAY();
ReceiveData <<= 1;
LCD_SCK_HIGH();
SET_LCD_CLK();
LCD_DELAY();
LCD_DELAY();
if (LCD_READ_DATA_PIN()) {
if (READ_LCD_DATA_PIN()) {
ReceiveData |= 0x01;
}
}
LCD_SCK_LOW();
LCD_MOSI_AS_OUTPUT();
CLR_LCD_CLK();
SET_LCD_DATA_OUTPUT();
return (ReceiveData);
}
@@ -1075,7 +1077,7 @@ unsigned int LCD_ST7796S_ReadID(void) {
lcdWriteCommand( 0XD3 );
LCD_MOSI_AS_INPUT();
SET_LCD_DATA_INPUT();
LCD_SCK_LOW();
LCD_DELAY();
LCD_DELAY();
radio/src/targets/nv14/lcd_driver.h
+19 -11
View File
@@ -50,22 +50,30 @@ extern lcdSpiInitFucPtr lcdOnFunction;
#define SET_IO_INPUT( PORT, PIN ) LL_GPIO_SetPinMode( PORT, PIN, LL_GPIO_MODE_INPUT )
#define SET_IO_OUTPUT( PORT, PIN ) LL_GPIO_SetPinMode( PORT, PIN, LL_GPIO_MODE_OUTPUT )
#define LCD_NRST_HIGH() LL_GPIO_SetOutputPin(LCD_NRST_GPIO, LCD_NRST_GPIO_PIN)
#define LCD_NRST_LOW() LL_GPIO_ResetOutputPin(LCD_NRST_GPIO, LCD_NRST_GPIO_PIN)
#define LCD_NRST_HIGH() gpio_write(LCD_NRST_GPIO, 1)
#define LCD_NRST_LOW() gpio_write(LCD_NRST_GPIO, 0)
#define LCD_CS_HIGH() LL_GPIO_SetOutputPin(LCD_SPI_GPIO, LCD_SPI_CS_GPIO_PIN)
#define LCD_CS_LOW() LL_GPIO_ResetOutputPin(LCD_SPI_GPIO, LCD_SPI_CS_GPIO_PIN)
#define LCD_CS_HIGH() gpio_write(LCD_SPI_CS_GPIO, 1)
#define LCD_CS_LOW() gpio_write(LCD_SPI_CS_GPIO, 0)
#define LCD_SCK_HIGH() LL_GPIO_SetOutputPin(LCD_SPI_GPIO, LCD_SPI_SCK_GPIO_PIN)
#define LCD_SCK_LOW() LL_GPIO_ResetOutputPin(LCD_SPI_GPIO, LCD_SPI_SCK_GPIO_PIN)
#define LCD_SCK_HIGH() gpio_write(LCD_SPI_SCK_GPIO, 1)
#define LCD_SCK_LOW() gpio_write(LCD_SPI_SCK_GPIO, 0)
#define LCD_MOSI_HIGH() LL_GPIO_SetOutputPin(LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN)
#define LCD_MOSI_LOW() LL_GPIO_ResetOutputPin(LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN)
#define LCD_MOSI_HIGH() gpio_write(LCD_SPI_MOSI_GPIO, 1)
#define LCD_MOSI_LOW() gpio_write(LCD_SPI_MOSI_GPIO, 0)
#define LCD_MOSI_AS_INPUT() SET_IO_INPUT( LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN )
#define LCD_MOSI_AS_OUTPUT() SET_IO_OUTPUT( LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN )
#define SET_LCD_CS() LCD_CS_HIGH()
#define CLR_LCD_CS() LCD_CS_LOW()
#define SET_LCD_CLK() LCD_SCK_HIGH()
#define CLR_LCD_CLK() LCD_SCK_LOW()
#define SET_LCD_DATA() gpio_write(LCD_SPI_MOSI_GPIO, 1)
#define CLR_LCD_DATA() gpio_write(LCD_SPI_MOSI_GPIO, 0)
#define SET_LCD_DATA_INPUT() gpio_init(LCD_SPI_MOSI_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW)
#define SET_LCD_DATA_OUTPUT() gpio_init(LCD_SPI_MOSI_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW)
#define READ_LCD_DATA_PIN() gpio_read(LCD_SPI_MOSI_GPIO)
#define LCD_READ_DATA_PIN() LL_GPIO_IsInputPinSet(LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN)
#if 1
radio/src/targets/nv14/sdram_driver.c
-257
View File
@@ -1,257 +0,0 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "board.h"
#include "stm32f4xx_fmc.h"
#define SDRAM_MODEREG_BURST_LENGTH_1 ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_LENGTH_2 ((uint16_t)0x0001)
#define SDRAM_MODEREG_BURST_LENGTH_4 ((uint16_t)0x0002)
#define SDRAM_MODEREG_BURST_LENGTH_8 ((uint16_t)0x0004)
#define SDRAM_MODEREG_BURST_FULL_PAGE ((uint16_t)0x0007)
#define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED ((uint16_t)0x0008)
#define SDRAM_MODEREG_CAS_LATENCY_1 ((uint16_t)0x0010)
#define SDRAM_MODEREG_CAS_LATENCY_2 ((uint16_t)0x0020)
#define SDRAM_MODEREG_CAS_LATENCY_3 ((uint16_t)0x0030)
#define SDRAM_MODEREG_OPERATING_MODE_STANDARD ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE ((uint16_t)0x0200)
void SDRAM_GPIOConfig(void)
{
/*
------------------------------------------------------------------------------------------------------------------------------------------------
PC3 <-> FMC_SDCKE0 | PD0 <-> FMC_D2 | PE0 <-> FMC_NBL0 | PF0 <-> FMC_A0 | PG0 <-> FMC_A10 | PH3 <-> FMC_SDNE0 | PI0 <-> FMC_D24
| PD1 <-> FMC_D3 | PE1 <-> FMC_NBL1 | PF1 <-> FMC_A1 | PG1 <-> FMC_A11 | PH5 <-> FMC_SDNWE | PI1 <-> FMC_D25
| PD8 <-> FMC_D13 | PE7 <-> FMC_D4 | PF2 <-> FMC_A2 | PG4 <-> FMC_BA0 | PH8 <-> FMC_D16 | PI2 <-> FMC_D26
| PD9 <-> FMC_D14 | PE8 <-> FMC_D5 | PF3 <-> FMC_A3 | PG5 <-> FMC_BA1 | PH9 <-> FMC_D17 | PI3 <-> FMC_D27
| PD10 <-> FMC_D15 | PE9 <-> FMC_D6 | PF4 <-> FMC_A4 | PG8 <-> FMC_SDCLK | PH10 <-> FMC_D18 | PI4 <-> FMC_NBL2
| PD14 <-> FMC_D0 | PE10 <-> FMC_D7 | PF5 <-> FMC_A5 | PG15 <-> FMC_NCAS | PH11 <-> FMC_D19 | PI5 <-> FMC_NBL3
| PD15 <-> FMC_D1 | PE11 <-> FMC_D8 | PF11 <-> FMC_NRAS | | PH12 <-> FMC_D20 | PI6 <-> FMC_D28
| | PE12 <-> FMC_D9 | PF12 <-> FMC_A6 | | PH13 <-> FMC_D21 | PI7 <-> FMC_D29
| | PE13 <-> FMC_D10 | PF13 <-> FMC_A7 | | PH14 <-> FMC_D22 | PI9 <-> FMC_D30
| | PE14 <-> FMC_D11 | PF14 <-> FMC_A8 | | PH15 <-> FMC_D23 | PI10 <-> FMC_D31
| | PE15 <-> FMC_D12 | PF15 <-> FMC_A9 | | |
*/
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
/* GPIOC configuration */
GPIO_PinAFConfig(GPIOC, GPIO_PinSource3 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 ;
GPIO_Init(GPIOC, &GPIO_InitStructure);
/* GPIOD configuration */
GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource8, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource9, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource10, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource14, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource15, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* GPIOE configuration */
GPIO_PinAFConfig(GPIOE, GPIO_PinSource0, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource1, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource7, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource8, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource9, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource10, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource11, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource12, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource13, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource14, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource15, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOE, &GPIO_InitStructure);
/* GPIOF configuration */
GPIO_PinAFConfig(GPIOF, GPIO_PinSource0, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource1, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource2, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource3, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource4, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource5, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource11, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource12, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource13, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource14, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource15, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOF, &GPIO_InitStructure);
/* GPIOG configuration */
GPIO_PinAFConfig(GPIOG, GPIO_PinSource0 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource1 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource4 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource5 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource8 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource15 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_8 | GPIO_Pin_15;
GPIO_Init(GPIOG, &GPIO_InitStructure);
/* GPIOH configuration */
GPIO_PinAFConfig(GPIOH, GPIO_PinSource3, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOH, GPIO_PinSource5, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_5;
GPIO_Init(GPIOH, &GPIO_InitStructure);
}
void SDRAM_InitSequence(void)
{
FMC_SDRAMCommandTypeDef FMC_SDRAMCommandStructure;
uint32_t tmpr = 0;
/* Step 3 --------------------------------------------------------------------*/
/* Configure a clock configuration enable command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_CLK_Enabled;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 4 --------------------------------------------------------------------*/
/* Insert 100 ms delay */
delay_ms(100);
/* Step 5 --------------------------------------------------------------------*/
/* Configure a PALL (precharge all) command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_PALL;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 6 --------------------------------------------------------------------*/
/* Configure a Auto-Refresh command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_AutoRefresh;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 4;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the first command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the second command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 7 --------------------------------------------------------------------*/
/* Program the external memory mode register */
tmpr = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_2 |
SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL |
SDRAM_MODEREG_CAS_LATENCY_3 |
SDRAM_MODEREG_OPERATING_MODE_STANDARD |
SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
/* Configure a load Mode register command*/
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_LoadMode;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = tmpr;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 8 --------------------------------------------------------------------*/
/* Set the refresh rate counter */
/* (15.62 us x Freq) - 20 */
/* Set the device refresh counter */
FMC_SetRefreshCount(683);//904
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
}
void SDRAM_Init(void)
{
//delay funcion needed
delaysInit();
// Clocks must be enabled here, because the sdramInit is called before main
RCC_AHB1PeriphClockCmd(SDRAM_RCC_AHB1Periph, ENABLE);
RCC_AHB3PeriphClockCmd(SDRAM_RCC_AHB3Periph, ENABLE);
/* GPIO configuration for FMC SDRAM bank */
SDRAM_GPIOConfig();
/* FMC Configuration ---------------------------------------------------------*/
FMC_SDRAMInitTypeDef FMC_SDRAMInitStructure;
FMC_SDRAMTimingInitTypeDef FMC_SDRAMTimingInitStructure;
/* FMC SDRAM Bank configuration */
/* Timing configuration for 90 Mhz of SD clock frequency (168Mhz/2) */
/* TMRD: 2 Clock cycles */
FMC_SDRAMTimingInitStructure.FMC_LoadToActiveDelay = 2;
/* TXSR: min=70ns (7x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_ExitSelfRefreshDelay = 7;
/* TRAS: min=42ns (4x11.11ns) max=120k (ns) */
FMC_SDRAMTimingInitStructure.FMC_SelfRefreshTime = 4;
/* TRC: min=70 (7x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_RowCycleDelay = 7;
/* TWR: min=1+ 7ns (1+1x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_WriteRecoveryTime = 2;
/* TRP: 20ns => 2x11.11ns */
FMC_SDRAMTimingInitStructure.FMC_RPDelay = 2;
/* TRCD: 20ns => 2x11.11ns */
FMC_SDRAMTimingInitStructure.FMC_RCDDelay = 2;
/* FMC SDRAM control configuration */
FMC_SDRAMInitStructure.FMC_Bank = FMC_Bank1_SDRAM;
/* Row addressing: [7:0] */
FMC_SDRAMInitStructure.FMC_ColumnBitsNumber = FMC_ColumnBits_Number_8b;
/* Column addressing: [11:0] */
FMC_SDRAMInitStructure.FMC_RowBitsNumber = FMC_RowBits_Number_12b;
FMC_SDRAMInitStructure.FMC_SDMemoryDataWidth = FMC_SDMemory_Width_16b;
FMC_SDRAMInitStructure.FMC_InternalBankNumber = FMC_InternalBank_Number_4;
FMC_SDRAMInitStructure.FMC_CASLatency = FMC_CAS_Latency_3;
FMC_SDRAMInitStructure.FMC_WriteProtection = FMC_Write_Protection_Disable;
FMC_SDRAMInitStructure.FMC_SDClockPeriod = FMC_SDClock_Period_2;
FMC_SDRAMInitStructure.FMC_ReadBurst = FMC_Read_Burst_Enable;
FMC_SDRAMInitStructure.FMC_ReadPipeDelay = FMC_ReadPipe_Delay_1;
FMC_SDRAMInitStructure.FMC_SDRAMTimingStruct = &FMC_SDRAMTimingInitStructure;
/* FMC SDRAM bank initialization */
FMC_SDRAMInit(&FMC_SDRAMInitStructure);
/* FMC SDRAM device initialization sequence */
SDRAM_InitSequence();
}
radio/src/targets/nv14/touch_driver.cpp
+6 -45
View File
@@ -19,6 +19,8 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_hal_ll.h"
#include "stm32_hal.h"
#include "stm32_i2c_driver.h"
@@ -66,46 +68,6 @@ static void _cst836u_exti_isr(void)
touchEventOccured = true;
}
static void TOUCH_AF_ExtiStop(void)
{
stm32_exti_disable(TOUCH_INT_EXTI_Line);
}
static void TOUCH_AF_ExtiConfig(void)
{
__HAL_RCC_SYSCFG_CLK_ENABLE();
LL_SYSCFG_SetEXTISource(TOUCH_INT_EXTI_Port, TOUCH_INT_EXTI_SysCfgLine);
stm32_exti_enable(TOUCH_INT_EXTI_Line,
LL_EXTI_TRIGGER_FALLING,
_cst836u_exti_isr);
}
static void TOUCH_AF_GPIOConfig(void)
{
LL_GPIO_InitTypeDef gpioInit;
LL_GPIO_StructInit(&gpioInit);
stm32_gpio_enable_clock(TOUCH_RST_GPIO);
stm32_gpio_enable_clock(TOUCH_INT_GPIO);
gpioInit.Mode = LL_GPIO_MODE_OUTPUT;
gpioInit.Speed = LL_GPIO_SPEED_FREQ_LOW;
gpioInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
gpioInit.Pull = LL_GPIO_PULL_NO;
gpioInit.Pin = TOUCH_RST_GPIO_PIN;
LL_GPIO_Init(TOUCH_RST_GPIO, &gpioInit);
LL_GPIO_SetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN);
gpioInit.Pin = TOUCH_INT_GPIO_PIN;
gpioInit.Mode = LL_GPIO_MODE_INPUT;
gpioInit.Pull = LL_GPIO_PULL_UP;
gpioInit.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
LL_GPIO_Init(TOUCH_INT_GPIO, &gpioInit);
LL_GPIO_SetOutputPin(TOUCH_INT_GPIO, TOUCH_INT_GPIO_PIN);
}
void I2C_Init_Radio(void)
{
TRACE("CST836U I2C Init");
@@ -397,9 +359,9 @@ static uint8_t cst836u_TS_DetectTouch()
void TouchReset()
{
LL_GPIO_ResetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN);
gpio_clear(TOUCH_RST_GPIO);
delay_ms(10);
LL_GPIO_SetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN);
gpio_set(TOUCH_RST_GPIO);
delay_ms(300);
}
@@ -433,12 +395,11 @@ void detectTouchController()
void TouchInit(void)
{
TOUCH_AF_GPIOConfig();
gpio_init(TOUCH_RST_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
I2C_Init_Radio();
TouchReset();
detectTouchController();
TOUCH_AF_ExtiConfig();
gpio_init_int(TOUCH_INT_GPIO, GPIO_IN_PU, GPIO_FALLING, _cst836u_exti_isr);
tc->printDebugInfo();
}
radio/src/targets/pl18/CMakeLists.txt
+1 -1
View File
@@ -115,11 +115,11 @@ set(FIRMWARE_TARGET_SRC
battery_driver.cpp
backlight_driver.cpp
led_driver.cpp
sdram_driver.c
)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/sdram_driver.cpp
targets/common/arm/stm32/audio_dac_driver.cpp
targets/common/arm/stm32/dma2d.cpp
targets/common/arm/stm32/spi_flash.cpp
radio/src/targets/pl18/backlight_driver.cpp
+9 -18
View File
@@ -19,6 +19,10 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
#include "opentx_types.h"
#include "board.h"
@@ -27,30 +31,17 @@
void backlightLowInit( void )
{
RCC_AHB1PeriphClockCmd(BACKLIGHT_RCC_AHB1Periph, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_WriteBit( BACKLIGHT_GPIO, BACKLIGHT_GPIO_PIN, Bit_RESET );
gpio_init(BACKLIGHT_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_clear(BACKLIGHT_GPIO);
}
void backlightInit()
{
// PIN init
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource, BACKLIGHT_GPIO_AF);
gpio_init_af(BACKLIGHT_GPIO, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
// TODO review this when the timer will be chosen
stm32_timer_enable_clock(BACKLIGHT_TIMER);
BACKLIGHT_TIMER->ARR = 100;
BACKLIGHT_TIMER->PSC = BACKLIGHT_TIMER_FREQ / 1000000 - 1; // 10kHz (same as FrOS)
BACKLIGHT_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1PE; // PWM mode 1
@@ -81,7 +72,7 @@ void lcdOff() {
backlightEnable(0);
}
void lcdOn(){
void lcdOn() {
if(lcdOnFunction) lcdOnFunction();
else lcdInit();
backlightEnable(BACKLIGHT_LEVEL_MAX);
radio/src/targets/pl18/battery_driver.cpp
+8 -25
View File
@@ -260,34 +260,20 @@ bool isChargerActive()
void battery_charge_init()
{
GPIO_InitTypeDef GPIO_InitStructure;
// Input pins
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
// USB charger status pins
GPIO_InitStructure.GPIO_Pin = UCHARGER_GPIO_PIN;
GPIO_Init(UCHARGER_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = UCHARGER_CHARGE_END_GPIO_PIN;
GPIO_Init(UCHARGER_CHARGE_END_GPIO, &GPIO_InitStructure);
gpio_init(UCHARGER_GPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
gpio_init(UCHARGER_CHARGE_END_GPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
#if defined(WIRELESS_CHARGER)
// Wireless charger status pins
GPIO_InitStructure.GPIO_Pin = WCHARGER_GPIO_PIN;
GPIO_Init(WCHARGER_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = WCHARGER_CHARGE_END_GPIO_PIN;
GPIO_Init(WCHARGER_CHARGE_END_GPIO, &GPIO_InitStructure);
gpio_init(WCHARGER_GPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
gpio_init(WCHARGER_CHARGE_END_GPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
#endif
// Output pins
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
// USB charger control pins
GPIO_InitStructure.GPIO_Pin = UCHARGER_EN_GPIO_PIN;
GPIO_Init(UCHARGER_EN_GPIO, &GPIO_InitStructure);
gpio_init(UCHARGER_EN_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
// USB charger state init
ENABLE_UCHARGER();
@@ -297,10 +283,8 @@ void battery_charge_init()
#if defined(WIRELESS_CHARGER)
// Wireless charger control pins
GPIO_InitStructure.GPIO_Pin = WCHARGER_EN_GPIO_PIN;
GPIO_Init(WCHARGER_EN_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = WCHARGER_I_CONTROL_GPIO_PIN;
GPIO_Init(WCHARGER_I_CONTROL_GPIO, &GPIO_InitStructure);
gpio_init(WCHARGER_EN_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(WCHARGER_I_CONTROL_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
// Wireless charger state init
ENABLE_WCHARGER();
@@ -308,7 +292,6 @@ void battery_charge_init()
wCharger.hasCharger = !IS_WCHARGER_ACTIVE(); // Init for sampling count works
wCharger.isChargerDetectionReady = false;
resetChargeEndDetection(&wCharger);
#endif
}
radio/src/targets/pl18/battery_driver.h
+13 -10
View File
@@ -31,6 +31,9 @@
#include "board.h"
#include "hal.h"
#include "hal/gpio.h"
#include "stm32_gpio.h"
enum ChargeState
{
CHARGE_UNKNOWN,
@@ -39,17 +42,17 @@ enum ChargeState
CHARGE_FINISHED
};
#define IS_UCHARGER_ACTIVE() GPIO_ReadInputDataBit(UCHARGER_GPIO, UCHARGER_GPIO_PIN)
#define IS_UCHARGER_CHARGE_END_ACTIVE() GPIO_ReadInputDataBit(UCHARGER_CHARGE_END_GPIO, UCHARGER_CHARGE_END_GPIO_PIN)
#define ENABLE_UCHARGER() GPIO_SetBits(UCHARGER_EN_GPIO, UCHARGER_EN_GPIO_PIN)
#define DISABLE_UCHARGER() GPIO_ResetBits(UCHARGER_EN_GPIO, UCHARGER_EN_GPIO_PIN)
#define IS_UCHARGER_ACTIVE() gpio_read(UCHARGER_GPIO) ? 1 : 0
#define IS_UCHARGER_CHARGE_END_ACTIVE() gpio_read(UCHARGER_CHARGE_END_GPIO) ? 1 : 0
#define ENABLE_UCHARGER() gpio_set(UCHARGER_EN_GPIO)
#define DISABLE_UCHARGER() gpio_clear(UCHARGER_EN_GPIO)
#define IS_WCHARGER_ACTIVE() GPIO_ReadInputDataBit(WCHARGER_GPIO, WCHARGER_GPIO_PIN)
#define IS_WCHARGER_CHARGE_END_ACTIVE() GPIO_ReadInputDataBit(WCHARGER_CHARGE_END_GPIO, WCHARGER_CHARGE_END_GPIO_PIN)
#define ENABLE_WCHARGER() GPIO_SetBits(WCHARGER_EN_GPIO, WCHARGER_EN_GPIO_PIN)
#define DISABLE_WCHARGER() GPIO_ResetBits(WCHARGER_EN_GPIO, WCHARGER_EN_GPIO_PIN)
#define WCHARGER_CURRENT_LOW() GPIO_ResetBits(WCHARGER_I_CONTROL_GPIO, WCHARGER_I_CONTROL_GPIO_PIN)
#define WCHARGER_CURRENT_HIGH() GPIO_SetBits(WCHARGER_I_CONTROL_GPIO, WCHARGER_I_CONTROL_GPIO_PIN)
#define IS_WCHARGER_ACTIVE() gpio_read(WCHARGER_GPIO) ? 1 : 0
#define IS_WCHARGER_CHARGE_END_ACTIVE() gpio_read(WCHARGER_CHARGE_END_GPIO) ? 1 : 0
#define ENABLE_WCHARGER() gpio_set(WCHARGER_EN_GPIO)
#define DISABLE_WCHARGER() gpio_clear(WCHARGER_EN_GPIO)
#define WCHARGER_CURRENT_LOW() gpio_set(WCHARGER_I_CONTROL_GPIO)
#define WCHARGER_CURRENT_HIGH() gpio_clear(WCHARGER_I_CONTROL_GPIO)
extern void battery_charge_init();
extern void handle_battery_charge(uint32_t last_press_time);
radio/src/targets/pl18/board.cpp
+9 -34
View File
@@ -20,6 +20,7 @@
*/
#include "stm32_adc.h"
#include "stm32_gpio.h"
#include "stm32_gpio_driver.h"
#include "stm32_ws2812.h"
@@ -34,6 +35,7 @@
#include "hal/abnormal_reboot.h"
#include "hal/watchdog_driver.h"
#include "hal/usb_driver.h"
#include "hal/gpio.h"
#include "globals.h"
#include "sdcard.h"
@@ -72,24 +74,8 @@ void delay_self(int count)
for (; count > 0; count--);
}
}
#define RCC_AHB1PeriphMinimum (PWR_RCC_AHB1Periph |\
LCD_RCC_AHB1Periph |\
BACKLIGHT_RCC_AHB1Periph |\
SDRAM_RCC_AHB1Periph \
)
#define RCC_AHB1PeriphOther (AUDIO_RCC_AHB1Periph |\
TELEMETRY_RCC_AHB1Periph |\
HAPTIC_RCC_AHB1Periph |\
INTMODULE_RCC_AHB1Periph |\
EXTMODULE_RCC_AHB1Periph \
)
#define RCC_AHB3PeriphMinimum (SDRAM_RCC_AHB3Periph)
#define RCC_APB1PeriphMinimum (BACKLIGHT_RCC_APB1Periph)
#define RCC_APB1PeriphOther (TELEMETRY_RCC_APB1Periph |\
AUDIO_RCC_APB1Periph \
)
#define RCC_AHB1PeriphMinimum (LCD_RCC_AHB1Periph)
#define RCC_APB2PeriphMinimum (LCD_RCC_APB2Periph)
#define RCC_APB2PeriphOther (HAPTIC_RCC_APB2Periph)
void ledStripOff()
{
@@ -102,14 +88,7 @@ void ledStripOff()
void boardBootloaderInit()
{
// USB charger status pins
stm32_gpio_enable_clock(UCHARGER_GPIO);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = UCHARGER_GPIO_PIN;
GPIO_Init(UCHARGER_GPIO, &GPIO_InitStructure);
gpio_init(UCHARGER_GPIO, GPIO_IN, GPIO_PIN_SPEED_LOW);
}
void boardInit()
@@ -119,11 +98,8 @@ void boardInit()
#endif
#if !defined(SIMU)
RCC_AHB1PeriphClockCmd(RCC_AHB1PeriphMinimum | RCC_AHB1PeriphOther, ENABLE);
RCC_AHB3PeriphClockCmd(RCC_AHB3PeriphMinimum, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1PeriphMinimum | RCC_APB1PeriphOther, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2PeriphMinimum | RCC_APB2PeriphOther, ENABLE);
LL_AHB1_GRP1_EnableClock(RCC_AHB1PeriphMinimum);
LL_APB2_GRP1_EnableClock(RCC_APB2PeriphMinimum);
// enable interrupts
__enable_irq();
#endif
@@ -195,13 +171,13 @@ void boardInit()
lcdSetInitalFrameBuffer(lcdFront->getData());
#if defined(DEBUG)
DBGMCU_APB1PeriphConfig(
/* DBGMCU_APB1PeriphConfig(
DBGMCU_IWDG_STOP | DBGMCU_TIM1_STOP | DBGMCU_TIM2_STOP |
DBGMCU_TIM3_STOP | DBGMCU_TIM4_STOP | DBGMCU_TIM5_STOP |
DBGMCU_TIM6_STOP | DBGMCU_TIM7_STOP | DBGMCU_TIM8_STOP |
DBGMCU_TIM9_STOP | DBGMCU_TIM10_STOP | DBGMCU_TIM11_STOP |
DBGMCU_TIM12_STOP | DBGMCU_TIM13_STOP | DBGMCU_TIM14_STOP,
ENABLE);
ENABLE);*/
#endif
}
@@ -263,8 +239,7 @@ int usbPlugged()
static uint8_t debouncedState = 0;
static uint8_t lastState = 0;
uint8_t state = GPIO_ReadInputDataBit(UCHARGER_GPIO, UCHARGER_GPIO_PIN);
uint8_t state = gpio_read(UCHARGER_GPIO) ? 1 : 0;
if (state == lastState)
debouncedState = state;
else
radio/src/targets/pl18/board.h
+7 -7
View File
@@ -63,18 +63,18 @@ uint32_t isFirmwareStart(const uint8_t * buffer);
uint32_t isBootloaderStart(const uint8_t * buffer);
// SDRAM driver
void SDRAM_Init();
extern "C" void SDRAM_Init();
// Pulses driver
#if !defined(SIMU)
#define INTERNAL_MODULE_ON() GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define INTERNAL_MODULE_OFF() GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_ON() GPIO_SetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_OFF() GPIO_ResetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define INTERNAL_MODULE_ON() gpio_set(INTMODULE_PWR_GPIO)
#define INTERNAL_MODULE_OFF() gpio_clear(INTMODULE_PWR_GPIO);
#define EXTERNAL_MODULE_ON() gpio_set(EXTMODULE_PWR_GPIO)
#define EXTERNAL_MODULE_OFF() gpio_clear(EXTMODULE_PWR_GPIO)
#define EXTERNAL_MODULE_PWR_OFF EXTERNAL_MODULE_OFF
#define BLUETOOTH_MODULE_ON() GPIO_ResetBits(BT_EN_GPIO, BT_EN_GPIO_PIN)
#define BLUETOOTH_MODULE_OFF() GPIO_SetBits(BT_EN_GPIO, BT_EN_GPIO_PIN)
#define BLUETOOTH_MODULE_ON() gpio_clear(BLUETOOTH_ON_GPIO)
#define BLUETOOTH_MODULE_OFF() gpio_set(BLUETOOTH_ON_GPIO)
#define IS_INTERNAL_MODULE_ON() (false)
#define IS_EXTERNAL_MODULE_ON() (GPIO_ReadInputDataBit(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN) == Bit_SET)
radio/src/targets/pl18/extmodule_helper.cpp
-49
View File
@@ -1,49 +0,0 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "board.h"
void EXTERNAL_MODULE_ON()
{
GPIO_SetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN);
}
void EXTERNAL_MODULE_OFF()
{
GPIO_ResetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN);
}
void extModuleInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_INVERT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(EXTMODULE_TX_INVERT_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = EXTMODULE_RX_INVERT_GPIO_PIN;
GPIO_Init(EXTMODULE_RX_INVERT_GPIO, &GPIO_InitStructure);
EXTMODULE_TX_INVERTED();
EXTMODULE_RX_INVERTED();
}
radio/src/targets/pl18/hal.h
+54 -106
View File
@@ -305,38 +305,21 @@
#endif
// Power
#define PWR_RCC_AHB1Periph RCC_AHB1Periph_GPIOI
#define PWR_ON_GPIO GPIOI
#define PWR_SWITCH_GPIO GPIOI
#define PWR_SWITCH_GPIO_PIN GPIO_Pin_11 // PI.11
#define PWR_ON_GPIO_PIN GPIO_Pin_14 // PI.14
#define PWR_SWITCH_GPIO GPIO_PIN(GPIOI, 11) // PI.11
#define PWR_ON_GPIO GPIO_PIN(GPIOI, 14) // PI.14
// Chargers (USB and wireless)
#define CHARGER_RCC_AHB1Periph ( RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_GPIOH | RCC_AHB1Periph_GPIOI )
#define UCHARGER_GPIO GPIO_PIN(GPIOB, 14) // PB.14 input
#define UCHARGER_GPIO GPIOB
#define UCHARGER_GPIO_PIN GPIO_Pin_14 // PB.14 input
#define UCHARGER_CHARGE_END_GPIO GPIO_PIN(GPIOB, 13) // PB.13 input
#define UCHARGER_CHARGE_END_GPIO GPIOB
#define UCHARGER_CHARGE_END_GPIO_PIN GPIO_Pin_13 // PB.13 input
#define UCHARGER_EN_GPIO GPIOG
#define UCHARGER_EN_GPIO_PIN GPIO_Pin_3 // PG.03 output
#define UCHARGER_EN_GPIO GPIO_PIN(GPIOG, 3) // PG.03 output
#if defined (WIRELESS_CHARGER)
#define WCHARGER_GPIO GPIOI
#define WCHARGER_GPIO_PIN GPIO_Pin_9 // PI.09 input
#define WCHARGER_CHARGE_END_GPIO GPIOI
#define WCHARGER_CHARGE_END_GPIO_PIN GPIO_Pin_10 // PI.10 input
#define WCHARGER_EN_GPIO GPIOH
#define WCHARGER_EN_GPIO_PIN GPIO_Pin_4 // PH.04 output
#define WCHARGER_I_CONTROL_GPIO GPIOH
#define WCHARGER_I_CONTROL_GPIO_PIN GPIO_Pin_13 // PH.13 output
#define WCHARGER_GPIO GPIO_PIN(GPIOI, 9) // PI.09 input
#define WCHARGER_CHARGE_END_GPIO GPIO_PIN(GPIOI, 10) // PI.10 input
#define WCHARGER_EN_GPIO GPIO_PIN(GPIOH, 4) // PH.04 output
#define WCHARGER_I_CONTROL_GPIO GPIO_PIN(GPIOH, 13) // PH.13 output
#endif
// TODO! Check IOLL1 to PI.01 connectivity!
@@ -376,29 +359,23 @@
// Telemetry
#define TELEMETRY_RCC_AHB1Periph (RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOJ | RCC_AHB1Periph_DMA1)
#define TELEMETRY_RCC_APB1Periph RCC_APB1Periph_USART2
#define TELEMETRY_REV_GPIO GPIOJ
#define TELEMETRY_RX_REV_GPIO_PIN GPIO_Pin_8 // PJ.08
#define TELEMETRY_TX_REV_GPIO_PIN GPIO_Pin_7 // PJ.07
#define TELEMETRY_DIR_GPIO GPIOJ
#define TELEMETRY_DIR_GPIO_PIN GPIO_Pin_13 // PJ.13
#define TELEMETRY_RX_REV_GPIO GPIO_PIN(GPIOJ, 8) // PJ.08
#define TELEMETRY_TX_REV_GPIO GPIO_PIN(GPIOJ, 7) // PJ.07
#define TELEMETRY_DIR_GPIO GPIO_PIN(GPIOJ, 13) // PJ.13
#define TELEMETRY_SET_INPUT 1
#define TELEMETRY_GPIO GPIOD
#define TELEMETRY_TX_GPIO_PIN GPIO_Pin_5 // PD.05
#define TELEMETRY_RX_GPIO_PIN GPIO_Pin_6 // PD.06
#define TELEMETRY_GPIO_PinSource_TX GPIO_PinSource5
#define TELEMETRY_GPIO_PinSource_RX GPIO_PinSource6
#define TELEMETRY_GPIO_AF GPIO_AF_USART2
#define TELEMETRY_TX_GPIO GPIO_PIN(GPIOD, 5) // PD.05
#define TELEMETRY_RX_GPIO GPIO_PIN(GPIOD, 6) // PD.06
#define TELEMETRY_USART USART2
#define TELEMETRY_USART_IRQn USART2_IRQn
#define TELEMETRY_DMA DMA1
#define TELEMETRY_DMA_Stream_TX LL_DMA_STREAM_6
#define TELEMETRY_DMA_Channel_TX DMA_Channel_4
#define TELEMETRY_DMA_Channel_TX LL_DMA_CHANNEL_4
#define TELEMETRY_DMA_TX_Stream_IRQ DMA1_Stream6_IRQn
#define TELEMETRY_DMA_TX_IRQHandler DMA1_Stream6_IRQHandler
#define TELEMETRY_DMA_TX_FLAG_TC DMA_IT_TCIF6
// #define TELEMETRY_DMA_Stream_RX LL_DMA_STREAM_5
// #define TELEMETRY_DMA_Channel_RX LL_DMA_CHANNEL_4
#define TELEMETRY_USART_IRQHandler USART2_IRQHandler
#define TELEMETRY_USART_IRQn USART2_IRQn
#define TELEMETRY_DIR_OUTPUT() TELEMETRY_DIR_GPIO->BSRRH = TELEMETRY_DIR_GPIO_PIN
#define TELEMETRY_DIR_INPUT() TELEMETRY_DIR_GPIO->BSRRL = TELEMETRY_DIR_GPIO_PIN
@@ -415,36 +392,28 @@
// USB
#define USB_RCC_AHB1Periph_GPIO RCC_AHB1Periph_GPIOA
#define USB_GPIO GPIOA
// #define USB_GPIO_PIN_VBUS LL_GPIO_PIN_9 // PA.09
#define USB_GPIO_PIN_ID LL_GPIO_PIN_10 // PA.10
#define USB_GPIO_PIN_DM LL_GPIO_PIN_11 // PA.11
#define USB_GPIO_PIN_DP LL_GPIO_PIN_12 // PA.12
#define USB_GPIO_AF GPIO_AF_OTG1_FS
// #define USB_GPIO_VBUS GPIO_PIN(GPIOA,9) // PA.09
#define USB_GPIO_DM GPIO_PIN(GPIOA, 11) // PA.11
#define USB_GPIO_DP GPIO_PIN(GPIOA, 12) // PA.12
#define USB_GPIO_AF GPIO_AF10
// LCD
#define LCD_RCC_AHB1Periph (RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_GPIOJ | RCC_AHB1Periph_GPIOK | RCC_AHB1Periph_DMA2D)
#define LCD_RCC_APB1Periph 0
#define LCD_RCC_APB2Periph RCC_APB2Periph_LTDC
#define LCD_NRST_GPIO GPIOG
#define LCD_NRST_GPIO_PIN LL_GPIO_PIN_9 // PG.09
#define LCD_SPI_GPIO GPIOE
#define LCD_SPI_CS_GPIO_PIN LL_GPIO_PIN_4 // PE.04
#define LCD_SPI_SCK_GPIO_PIN LL_GPIO_PIN_2 // PE.02
#define LCD_SPI_MISO_GPIO_PIN LL_GPIO_PIN_5 // PE.05
#define LCD_SPI_MOSI_GPIO_PIN LL_GPIO_PIN_6 // PE.06
#define LCD_RCC_AHB1Periph LL_AHB1_GRP1_PERIPH_DMA2D
#define LCD_RCC_APB2Periph LL_APB2_GRP1_PERIPH_LTDC
#define LCD_NRST_GPIO GPIO_PIN(GPIOG, 9) // PG.09
#define LCD_SPI_CS_GPIO GPIO_PIN(GPIOE, 4) // PE.04
#define LCD_SPI_SCK_GPIO GPIO_PIN(GPIOE, 2) // PE.02
#define LCD_SPI_MISO_GPIO GPIO_PIN(GPIOE, 5) // PE.05
#define LCD_SPI_MOSI_GPIO GPIO_PIN(GPIOE, 6) // PE.06
#define LTDC_IRQ_PRIO 4
#define DMA_SCREEN_IRQ_PRIO 6
// Backlight
// TODO TIM3, TIM8, TIM14, review the channel in backlight_driver.cpp according to the chosen timer
#define BACKLIGHT_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define BACKLIGHT_RCC_APB1Periph RCC_APB1Periph_TIM2
#define BACKLIGHT_RCC_APB2Periph 0
#define BACKLIGHT_GPIO GPIOA
#define BACKLIGHT_GPIO_PIN GPIO_Pin_15
#define BACKLIGHT_GPIO_PinSource GPIO_PinSource15
#define BACKLIGHT_GPIO GPIO_PIN(GPIOA, 15)
#define BACKLIGHT_TIMER TIM2
#define BACKLIGHT_GPIO_AF GPIO_AF_TIM2
#define BACKLIGHT_GPIO_AF GPIO_AF1
#define BACKLIGHT_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
//used in BOOTLOADER
@@ -473,9 +442,7 @@
// Audio
#define AUDIO_RCC_APB1Periph (RCC_APB1Periph_TIM6 | RCC_APB1Periph_DAC)
#define AUDIO_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_DMA1)
#define AUDIO_OUTPUT_GPIO GPIOA
#define AUDIO_OUTPUT_GPIO_PIN GPIO_Pin_4 // PA.04
#define AUDIO_GPIO_PinSource GPIO_PinSource4
#define AUDIO_OUTPUT_GPIO GPIO_PIN(GPIOA, 4) // PA.04
#define AUDIO_DMA_Stream DMA1_Stream5
#define AUDIO_DMA_Stream_IRQn DMA1_Stream5_IRQn
#define AUDIO_TIM_IRQn TIM6_DAC_IRQn
@@ -494,10 +461,8 @@
// Touch
#define TOUCH_I2C_BUS I2C_Bus_1
#define TOUCH_I2C_CLK_RATE 400000
#define TOUCH_INT_GPIO GPIOB
#define TOUCH_INT_GPIO_PIN LL_GPIO_PIN_9 // PB.09
#define TOUCH_RST_GPIO GPIOB
#define TOUCH_RST_GPIO_PIN LL_GPIO_PIN_12 // PB.12
#define TOUCH_INT_GPIO GPIO_PIN(GPIOB, 9) // PB.09
#define TOUCH_RST_GPIO GPIO_PIN(GPIOB, 12) // PB.12
#define TOUCH_INT_EXTI_Line LL_EXTI_LINE_9
#define TOUCH_INT_EXTI_Port LL_SYSCFG_EXTI_PORTB
#define TOUCH_INT_EXTI_SysCfgLine LL_SYSCFG_EXTI_LINE9
@@ -510,23 +475,18 @@
// Haptic: TIM1_CH1
#define HAPTIC_PWM
#define HAPTIC_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define HAPTIC_RCC_APB2Periph RCC_APB2ENR_TIM1EN
#define HAPTIC_GPIO GPIOA
#define HAPTIC_GPIO_PIN GPIO_Pin_8
#define HAPTIC_GPIO GPIO_PIN(GPIOA, 8) // PA.08
#define HAPTIC_GPIO_TIMER TIM1
#define HAPTIC_GPIO_AF GPIO_AF_TIM1
#define HAPTIC_GPIO_PinSource GPIO_PinSource8
#define HAPTIC_GPIO_AF GPIO_AF1
#define HAPTIC_TIMER_OUTPUT_ENABLE TIM_CCER_CC1E | TIM_CCER_CC1NE;
#define HAPTIC_TIMER_MODE TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1PE
#define HAPTIC_TIMER_COMPARE_VALUE HAPTIC_GPIO_TIMER->CCR1
// Flysky Hall Stick
#define FLYSKY_HALL_SERIAL_USART UART4
#define FLYSKY_HALL_SERIAL_GPIO GPIOA
#define FLYSKY_HALL_DMA_Channel LL_DMA_CHANNEL_4
#define FLYSKY_HALL_SERIAL_TX_GPIO_PIN LL_GPIO_PIN_0 // PA.00
#define FLYSKY_HALL_SERIAL_RX_GPIO_PIN LL_GPIO_PIN_1 // PA.01
#define FLYSKY_HALL_SERIAL_TX_GPIO GPIO_PIN(GPIOA, 0) // PA.00
#define FLYSKY_HALL_SERIAL_RX_GPIO GPIO_PIN(GPIOA, 1) // PA.01
#define FLYSKY_HALL_SERIAL_GPIO_AF LL_GPIO_AF_8
#define FLYSKY_HALL_RCC_AHB1Periph RCC_AHB1Periph_DMA1
@@ -540,9 +500,8 @@
// LED Strip
#define LED_STRIP_LENGTH 4
#define LED_STRIP_GPIO GPIOH
#define LED_STRIP_GPIO_PIN_DATA LL_GPIO_PIN_12 // PH.12 / TIM5_CH3
#define LED_STRIP_GPIO_PIN_AF LL_GPIO_AF_2 // TIM3/4/5
#define LED_STRIP_GPIO GPIO_PIN(GPIOH, 12) // PH.12 / TIM5_CH3
#define LED_STRIP_GPIO_AF LL_GPIO_AF_2 // TIM3/4/5
#define LED_STRIP_TIMER TIM5
#define LED_STRIP_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define LED_STRIP_TIMER_CHANNEL LL_TIM_CHANNEL_CH3
@@ -559,11 +518,9 @@
// Internal Module
#if defined(RADIO_PL18)
#define INTMODULE_RCC_AHB1Periph (RCC_AHB1Periph_GPIOF | RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_DMA1)
#define INTMODULE_PWR_GPIO GPIOI
#define INTMODULE_PWR_GPIO_PIN GPIO_Pin_0 // PI.00
#define INTMODULE_GPIO GPIOF
#define INTMODULE_TX_GPIO_PIN LL_GPIO_PIN_7 // PF.07
#define INTMODULE_RX_GPIO_PIN LL_GPIO_PIN_6 // PF.06
#define INTMODULE_PWR_GPIO GPIO_PIN(GPIOI, 0) // PI.00
#define INTMODULE_TX_GPIO GPIO_PIN(GPIOF, 7) // PF.07
#define INTMODULE_RX_GPIO GPIO_PIN(GPIOF, 6) // PF.06
#define INTMODULE_USART UART7
#define INTMODULE_GPIO_AF LL_GPIO_AF_8
#define INTMODULE_USART_IRQn UART7_IRQn
@@ -590,17 +547,11 @@
// External Module
#define EXTMODULE
#define EXTMODULE_PULSES
#define EXTMODULE_PWR_GPIO GPIOD
#define EXTMODULE_PWR_GPIO_PIN GPIO_Pin_11 // PD.11
#define EXTMODULE_RCC_AHB1Periph \
(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOC | \
RCC_AHB1Periph_GPIOI | RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_DMA2)
#define EXTMODULE_TX_GPIO GPIOC
#define EXTMODULE_TX_GPIO_PIN LL_GPIO_PIN_6 // PC.06
#define EXTMODULE_PWR_GPIO GPIO_PIN(GPIOD, 11) // PD.11
#define EXTMODULE_TX_GPIO GPIO_PIN(GPIOC, 6) // PC.06
#define EXTMODULE_RX_GPIO GPIO_PIN(GPIOC, 7) // PC.07
#define EXTMODULE_TX_GPIO_AF LL_GPIO_AF_3 // TIM8_CH1
#define EXTMODULE_TX_GPIO_AF_USART GPIO_AF_USART6
#define EXTMODULE_RX_GPIO GPIOC
#define EXTMODULE_RX_GPIO_PIN LL_GPIO_PIN_7 // PC.07
#define EXTMODULE_RX_GPIO_AF_USART GPIO_AF_USART6
#define EXTMODULE_TIMER TIM8
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH1
@@ -615,28 +566,23 @@
#define EXTMODULE_USART_GPIO_AF_LL LL_GPIO_AF_8
#define EXTMODULE_USART_TX_DMA DMA2
#define EXTMODULE_USART_TX_DMA_CHANNEL LL_DMA_CHANNEL_5
#define EXTMODULE_USART_TX_DMA_STREAM DMA2_Stream7
#define EXTMODULE_USART_TX_DMA_STREAM_LL LL_DMA_STREAM_7
#define EXTMODULE_USART_TX_DMA_STREAM LL_DMA_STREAM_7
#define EXTMODULE_USART_RX_DMA_CHANNEL LL_DMA_CHANNEL_5
#define EXTMODULE_USART_RX_DMA_STREAM DMA2_Stream2
#define EXTMODULE_USART_RX_DMA_STREAM_LL LL_DMA_STREAM_2
#define EXTMODULE_USART_RX_DMA_STREAM LL_DMA_STREAM_2
#define EXTMODULE_USART_IRQHandler USART6_IRQHandler
#define EXTMODULE_USART_IRQn USART6_IRQn
//TIMER
#define EXTMODULE_TIMER_DMA_CHANNEL LL_DMA_CHANNEL_7
#define EXTMODULE_TIMER_DMA_STREAM DMA2_Stream1
#define EXTMODULE_TIMER_DMA DMA2
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_STREAM LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream1_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA2_Stream1_IRQHandler
#define EXTMODULE_TX_INVERT_GPIO GPIOE
#define EXTMODULE_TX_INVERT_GPIO_PIN GPIO_Pin_3 // PE.03
#define EXTMODULE_RX_INVERT_GPIO GPIOI
#define EXTMODULE_RX_INVERT_GPIO_PIN GPIO_Pin_15 // PI.15
#define EXTMODULE_TX_INVERT_GPIO GPIO_PIN(GPIOE, 3) // PE.03
#define EXTMODULE_RX_INVERT_GPIO GPIO_PIN(GPIOI, 15) // PI.15
#define EXTMODULE_TX_NORMAL() EXTMODULE_TX_INVERT_GPIO->BSRRH = EXTMODULE_TX_INVERT_GPIO_PIN
#define EXTMODULE_TX_INVERTED() EXTMODULE_TX_INVERT_GPIO->BSRRL = EXTMODULE_TX_INVERT_GPIO_PIN
@@ -644,12 +590,11 @@
#define EXTMODULE_RX_INVERTED() EXTMODULE_RX_INVERT_GPIO->BSRRL = EXTMODULE_RX_INVERT_GPIO_PIN
// Trainer Port
#define TRAINER_GPIO GPIOD
#define TRAINER_IN_GPIO_PIN LL_GPIO_PIN_12 // PD.12
#define TRAINER_IN_GPIO GPIO_PIN(GPIOD, 12) // PD.12
#define TRAINER_IN_TIMER_Channel LL_TIM_CHANNEL_CH1
#define TRAINER_OUT_GPIO_PIN LL_GPIO_PIN_13 // PD.13
#define TRAINER_OUT_GPIO GPIO_PIN(GPIOD, 13) // PD.13
#define TRAINER_OUT_TIMER_Channel LL_TIM_CHANNEL_CH2
#define TRAINER_TIMER TIM4
@@ -696,6 +641,9 @@
#define MIXER_SCHEDULER_TIMER_IRQn TIM8_BRK_TIM12_IRQn
#define MIXER_SCHEDULER_TIMER_IRQHandler TIM8_BRK_TIM12_IRQHandler
// SDRAM
#define SDRAM_BANK1
#define LCD_W 480
#define LCD_H 320
radio/src/targets/pl18/haptic_driver.cpp
+6 -10
View File
@@ -20,6 +20,10 @@
*/
#include "board.h"
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
void hapticOff(void)
{
@@ -36,16 +40,9 @@ void hapticOn(uint32_t pwmPercent)
void hapticInit(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = HAPTIC_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(HAPTIC_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(HAPTIC_GPIO, HAPTIC_GPIO_PinSource, HAPTIC_GPIO_AF);
gpio_init_af(HAPTIC_GPIO, HAPTIC_GPIO_AF, GPIO_PIN_SPEED_LOW);
stm32_timer_enable_clock(HAPTIC_GPIO_TIMER);
HAPTIC_GPIO_TIMER->ARR = 100;
HAPTIC_GPIO_TIMER->PSC = (PERI2_FREQUENCY * TIMER_MULT_APB2) / 10000 - 1;
HAPTIC_GPIO_TIMER->CCMR1 = HAPTIC_TIMER_MODE; // PWM
@@ -59,5 +56,4 @@ void hapticInit(void)
void hapticDone(void)
{
hapticOff();
RCC_AHB1PeriphClockCmd(HAPTIC_RCC_AHB1Periph, DISABLE);
}
radio/src/targets/pl18/lcd_driver.cpp
+84 -81
View File
@@ -24,6 +24,8 @@
#include "opentx_types.h"
#include "dma2d.h"
#include "hal.h"
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "delays_driver.h"
#include "debug.h"
#include "lcd.h"
@@ -36,6 +38,8 @@ static volatile uint16_t lcd_phys_h = LCD_PHYS_H;
static LTDC_HandleTypeDef hltdc;
static void* initialFrameBuffer = nullptr;
#define GPIO_AF_LTDC GPIO_AF14
static volatile uint8_t _frame_addr_reloaded = 0;
static void startLcdRefresh(lv_disp_drv_t *disp_drv, uint16_t *buffer,
@@ -79,65 +83,64 @@ enum ENUM_IO_MODE
IO_MODE_ANALOG
};
static void LCD_AF_GPIOConfig(void) {
static void LCD_AF_GPIOConfig(void)
{
/* GPIOs Configuration */
/*
-----------------------------------------------------------------------------
LCD_CLK <-> PG.07 | LCD_HSYNC <-> PI.12 | LCD_R3 <-> PJ.02 | LCD_G5 <-> PK.00
| LCD VSYNC <-> PI.13 | LCD_R4 <-> PJ.03 | LCD_G6 <-> PK.01
| | LCD_R5 <-> PJ.04 | LCD_G7 <-> PK.02
| | LCD_R6 <-> PJ.05 | LCD_B4 <-> PK.03
| | LCD_R7 <-> PJ.06 | LCD_B5 <-> PK.04
| | LCD_G2 <-> PJ.09 | LCD_B6 <-> PK.05
| | LCD_G3 <-> PJ.10 | LCD_B7 <-> PK.06
| | LCD_G4 <-> PJ.11 | LCD_DE <-> PK.07
| | LCD_B3 <-> PJ.15 |
+---------------------+---------------------+------------------+------------------+
+ LCD pins assignment +
+---------------------+---------------------+------------------+------------------+
| LCD_CLK <-> PG.07 | LCD_HSYNC <-> PI.12 | LCD_R3 <-> PJ.02 | LCD_G5 <-> PK.00 |
| LCD VSYNC <-> PI.13 | LCD_R4 <-> PJ.03 | LCD_G6 <-> PK.01 | |
| | LCD_R5 <-> PJ.04 | LCD_G7 <-> PK.02 | |
| | LCD_R6 <-> PJ.05 | LCD_B4 <-> PK.03 | |
| | LCD_R7 <-> PJ.06 | LCD_B5 <-> PK.04 | |
| | LCD_G2 <-> PJ.09 | LCD_B6 <-> PK.05 | |
| | LCD_G3 <-> PJ.10 | LCD_B7 <-> PK.06 | |
| | LCD_G4 <-> PJ.11 | LCD_DE <-> PK.07 | |
| | LCD_B3 <-> PJ.15 | | |
+---------------------+---------------------+------------------+------------------+
*/
LL_GPIO_InitTypeDef GPIO_InitStructure;
LL_GPIO_StructInit(&GPIO_InitStructure);
// GPIOG configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_7;
GPIO_InitStructure.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStructure.Mode = LL_GPIO_MODE_ALTERNATE;
GPIO_InitStructure.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStructure.Pull = LL_GPIO_PULL_NO;
GPIO_InitStructure.Alternate = LL_GPIO_AF_14; // AF LTDC
LL_GPIO_Init(GPIOG, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOG, 7), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
// GPIOI configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_12 | LL_GPIO_PIN_13;
LL_GPIO_Init(GPIOI, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOI, 12), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOI, 13), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
// GPIOJ configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_2 | LL_GPIO_PIN_3 | LL_GPIO_PIN_4 | LL_GPIO_PIN_5 | LL_GPIO_PIN_6 | LL_GPIO_PIN_9 | LL_GPIO_PIN_10 | LL_GPIO_PIN_11 | LL_GPIO_PIN_15;
LL_GPIO_Init(GPIOJ, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOJ, 2), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 3), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 4), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 5), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 6), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 9), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 10), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 11), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOJ, 15), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
// GPIOK configuration
GPIO_InitStructure.Pin = LL_GPIO_PIN_0 | LL_GPIO_PIN_1 | LL_GPIO_PIN_2 | LL_GPIO_PIN_3 | LL_GPIO_PIN_4 | LL_GPIO_PIN_5 | LL_GPIO_PIN_6 | LL_GPIO_PIN_7;
LL_GPIO_Init(GPIOK, &GPIO_InitStructure);
gpio_init_af(GPIO_PIN(GPIOK, 0), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 1), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 2), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 3), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 4), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 5), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 6), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
gpio_init_af(GPIO_PIN(GPIOK, 7), GPIO_AF_LTDC, GPIO_PIN_SPEED_LOW);
}
static void lcdSpiConfig(void) {
LL_GPIO_InitTypeDef GPIO_InitStructure;
LL_GPIO_StructInit(&GPIO_InitStructure);
static void lcdSpiConfig(void)
{
gpio_init(LCD_SPI_SCK_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_SPI_MOSI_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_SPI_CS_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_NRST_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
GPIO_InitStructure.Pin = LCD_SPI_SCK_GPIO_PIN | LCD_SPI_MOSI_GPIO_PIN;
GPIO_InitStructure.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStructure.Mode = LL_GPIO_MODE_OUTPUT;
GPIO_InitStructure.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStructure.Pull = LL_GPIO_PULL_NO;
LL_GPIO_Init(LCD_SPI_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.Pin = LCD_SPI_CS_GPIO_PIN;
GPIO_InitStructure.Pull = LL_GPIO_PULL_UP;
LL_GPIO_Init(LCD_SPI_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.Pin = LCD_NRST_GPIO_PIN;
LL_GPIO_Init(LCD_NRST_GPIO, &GPIO_InitStructure);
/* Set the chip select pin always low */
LCD_CS_LOW();
/* Set the chip select pin aways low */
CLR_LCD_CS();
}
void lcdDelay() {
@@ -145,13 +148,13 @@ void lcdDelay() {
}
static void lcdReset() {
LCD_NRST_HIGH();
SET_LCD_NRST();
delay_ms(1);
LCD_NRST_LOW(); // RESET();
CLR_LCD_NRST(); // RESET();
delay_ms(100);
LCD_NRST_HIGH();
SET_LCD_NRST();
delay_ms(100);
}
@@ -159,106 +162,106 @@ unsigned char LCD_ReadByteOnFallingEdge(void) {
unsigned int i;
unsigned char ReceiveData = 0;
LCD_MOSI_HIGH();
LCD_MOSI_AS_INPUT();
SET_LCD_DATA();
SET_LCD_DATA_INPUT();
for (i = 0; i < 8; i++) {
lcdDelay();
LCD_SCK_HIGH();
SET_LCD_CLK();
lcdDelay();
lcdDelay();
ReceiveData <<= 1;
LCD_SCK_LOW();
CLR_LCD_CLK();
lcdDelay();
lcdDelay();
if (LCD_READ_DATA_PIN()) {
if (READ_LCD_DATA_PIN()) {
ReceiveData |= 0x01;
}
}
LCD_MOSI_AS_OUTPUT();
SET_LCD_DATA_OUTPUT();
return (ReceiveData);
}
static void lcdWriteByte(uint8_t data_enable, uint8_t byte) {
LCD_SCK_LOW();
CLR_LCD_CLK();
if (data_enable) {
LCD_MOSI_HIGH();
SET_LCD_DATA();
} else {
LCD_MOSI_LOW();
CLR_LCD_DATA();
}
lcdDelay();
LCD_SCK_HIGH();
SET_LCD_CLK();
for (int i = 0; i < 8; i++) {
lcdDelay();
LCD_SCK_LOW();
CLR_LCD_CLK();
if (byte & 0x80) {
LCD_MOSI_HIGH();
SET_LCD_DATA();
} else {
LCD_MOSI_LOW();
CLR_LCD_DATA();
}
lcdDelay();
LCD_SCK_HIGH();
SET_LCD_CLK();
byte <<= 1;
}
lcdDelay();
LCD_SCK_LOW();
CLR_LCD_CLK();
}
unsigned char LCD_ReadByte(void) {
unsigned int i;
unsigned char ReceiveData = 0;
LCD_MOSI_HIGH();
LCD_MOSI_AS_INPUT();
SET_LCD_DATA();
SET_LCD_DATA_INPUT();
for (i = 0; i < 8; i++) {
LCD_SCK_LOW();
CLR_LCD_CLK();
lcdDelay();
ReceiveData <<= 1;
LCD_SCK_HIGH();
SET_LCD_CLK();
lcdDelay();
if (LCD_READ_DATA_PIN()) {
if (READ_LCD_DATA_PIN()) {
ReceiveData |= 0x01;
}
}
LCD_SCK_LOW();
LCD_MOSI_AS_OUTPUT();
CLR_LCD_CLK();
SET_LCD_DATA_OUTPUT();
return (ReceiveData);
}
unsigned char LCD_ReadRegister(unsigned char Register) {
unsigned char ReadData = 0;
LCD_CS_LOW();
CLR_LCD_CS();
lcdWriteByte(0, Register);
lcdDelay();
lcdDelay();
ReadData = LCD_ReadByte();
LCD_CS_HIGH();
SET_LCD_CS();
lcdDelay();
return (ReadData);
}
void lcdWriteCommand(uint8_t command) {
LCD_CS_LOW();
CLR_LCD_CS();
lcdWriteByte(0, command);
LCD_CS_HIGH();
SET_LCD_CS();
lcdDelay();
}
void lcdWriteData(uint8_t data) {
LCD_CS_LOW();
CLR_LCD_CS();
lcdWriteByte(1, data);
LCD_CS_HIGH();
SET_LCD_CS();
lcdDelay();
}
@@ -1274,11 +1277,11 @@ unsigned int LCD_ST7796S_ReadID(void) {
lcdWriteCommand( 0XD3 );
LCD_MOSI_AS_INPUT();
LCD_SCK_LOW();
SET_LCD_DATA_INPUT();
CLR_LCD_CLK();
lcdDelay();
lcdDelay();
LCD_SCK_HIGH();
SET_LCD_CLK();
lcdDelay();
lcdDelay();
radio/src/targets/pl18/lcd_driver.h
+11 -16
View File
@@ -44,25 +44,20 @@ extern lcdSpiInitFucPtr lcdInitFunction;
extern lcdSpiInitFucPtr lcdOffFunction;
extern lcdSpiInitFucPtr lcdOnFunction;
#define SET_IO_INPUT( PORT, PIN ) LL_GPIO_SetPinMode( PORT, PIN, LL_GPIO_MODE_INPUT )
#define SET_IO_OUTPUT( PORT, PIN ) LL_GPIO_SetPinMode( PORT, PIN, LL_GPIO_MODE_OUTPUT )
#define SET_LCD_NRST() gpio_write(LCD_NRST_GPIO, 1)
#define CLR_LCD_NRST() gpio_write(LCD_NRST_GPIO, 0)
#define LCD_NRST_HIGH() LL_GPIO_SetOutputPin(LCD_NRST_GPIO, LCD_NRST_GPIO_PIN)
#define LCD_NRST_LOW() LL_GPIO_ResetOutputPin(LCD_NRST_GPIO, LCD_NRST_GPIO_PIN)
#define SET_LCD_CS() gpio_write(LCD_SPI_CS_GPIO, 1)
#define CLR_LCD_CS() gpio_write(LCD_SPI_CS_GPIO, 0)
#define LCD_CS_HIGH() LL_GPIO_SetOutputPin(LCD_SPI_GPIO, LCD_SPI_CS_GPIO_PIN)
#define LCD_CS_LOW() LL_GPIO_ResetOutputPin(LCD_SPI_GPIO, LCD_SPI_CS_GPIO_PIN)
#define SET_LCD_CLK() gpio_write(LCD_SPI_SCK_GPIO, 1)
#define CLR_LCD_CLK() gpio_write(LCD_SPI_SCK_GPIO, 0)
#define LCD_SCK_HIGH() LL_GPIO_SetOutputPin(LCD_SPI_GPIO, LCD_SPI_SCK_GPIO_PIN)
#define LCD_SCK_LOW() LL_GPIO_ResetOutputPin(LCD_SPI_GPIO, LCD_SPI_SCK_GPIO_PIN)
#define LCD_MOSI_HIGH() LL_GPIO_SetOutputPin(LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN)
#define LCD_MOSI_LOW() LL_GPIO_ResetOutputPin(LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN)
#define LCD_MOSI_AS_INPUT() SET_IO_INPUT( LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN )
#define LCD_MOSI_AS_OUTPUT() SET_IO_OUTPUT( LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN )
#define LCD_READ_DATA_PIN() LL_GPIO_IsInputPinSet(LCD_SPI_GPIO, LCD_SPI_MOSI_GPIO_PIN)
#define SET_LCD_DATA() gpio_write(LCD_SPI_MOSI_GPIO, 1)
#define CLR_LCD_DATA() gpio_write(LCD_SPI_MOSI_GPIO, 0)
#define SET_LCD_DATA_INPUT() gpio_init(LCD_SPI_MOSI_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW)
#define SET_LCD_DATA_OUTPUT() gpio_init(LCD_SPI_MOSI_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW)
#define READ_LCD_DATA_PIN() gpio_read(LCD_SPI_MOSI_GPIO)
#if 1
radio/src/targets/pl18/sdram_driver.c
-257
View File
@@ -1,257 +0,0 @@
/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "board.h"
#include "stm32f4xx_fmc.h"
#define SDRAM_MODEREG_BURST_LENGTH_1 ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_LENGTH_2 ((uint16_t)0x0001)
#define SDRAM_MODEREG_BURST_LENGTH_4 ((uint16_t)0x0002)
#define SDRAM_MODEREG_BURST_LENGTH_8 ((uint16_t)0x0004)
#define SDRAM_MODEREG_BURST_FULL_PAGE ((uint16_t)0x0007)
#define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED ((uint16_t)0x0008)
#define SDRAM_MODEREG_CAS_LATENCY_1 ((uint16_t)0x0010)
#define SDRAM_MODEREG_CAS_LATENCY_2 ((uint16_t)0x0020)
#define SDRAM_MODEREG_CAS_LATENCY_3 ((uint16_t)0x0030)
#define SDRAM_MODEREG_OPERATING_MODE_STANDARD ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE ((uint16_t)0x0200)
void SDRAM_GPIOConfig(void)
{
/*
------------------------------------------------------------------------------------------------------------------------------------------------
PC3 <-> FMC_SDCKE0 | PD0 <-> FMC_D2 | PE0 <-> FMC_NBL0 | PF0 <-> FMC_A0 | PG0 <-> FMC_A10 | PH3 <-> FMC_SDNE0 | PI0 <-> FMC_D24
| PD1 <-> FMC_D3 | PE1 <-> FMC_NBL1 | PF1 <-> FMC_A1 | PG1 <-> FMC_A11 | PH5 <-> FMC_SDNWE | PI1 <-> FMC_D25
| PD8 <-> FMC_D13 | PE7 <-> FMC_D4 | PF2 <-> FMC_A2 | PG4 <-> FMC_BA0 | PH8 <-> FMC_D16 | PI2 <-> FMC_D26
| PD9 <-> FMC_D14 | PE8 <-> FMC_D5 | PF3 <-> FMC_A3 | PG5 <-> FMC_BA1 | PH9 <-> FMC_D17 | PI3 <-> FMC_D27
| PD10 <-> FMC_D15 | PE9 <-> FMC_D6 | PF4 <-> FMC_A4 | PG8 <-> FMC_SDCLK | PH10 <-> FMC_D18 | PI4 <-> FMC_NBL2
| PD14 <-> FMC_D0 | PE10 <-> FMC_D7 | PF5 <-> FMC_A5 | PG15 <-> FMC_NCAS | PH11 <-> FMC_D19 | PI5 <-> FMC_NBL3
| PD15 <-> FMC_D1 | PE11 <-> FMC_D8 | PF11 <-> FMC_NRAS | | PH12 <-> FMC_D20 | PI6 <-> FMC_D28
| | PE12 <-> FMC_D9 | PF12 <-> FMC_A6 | | PH13 <-> FMC_D21 | PI7 <-> FMC_D29
| | PE13 <-> FMC_D10 | PF13 <-> FMC_A7 | | PH14 <-> FMC_D22 | PI9 <-> FMC_D30
| | PE14 <-> FMC_D11 | PF14 <-> FMC_A8 | | PH15 <-> FMC_D23 | PI10 <-> FMC_D31
| | PE15 <-> FMC_D12 | PF15 <-> FMC_A9 | | |
*/
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
/* GPIOC configuration */
GPIO_PinAFConfig(GPIOC, GPIO_PinSource3 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 ;
GPIO_Init(GPIOC, &GPIO_InitStructure);
/* GPIOD configuration */
GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource8, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource9, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource10, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource14, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource15, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* GPIOE configuration */
GPIO_PinAFConfig(GPIOE, GPIO_PinSource0, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource1, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource7, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource8, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource9, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource10, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource11, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource12, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource13, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource14, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource15, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOE, &GPIO_InitStructure);
/* GPIOF configuration */
GPIO_PinAFConfig(GPIOF, GPIO_PinSource0, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource1, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource2, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource3, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource4, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource5, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource11, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource12, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource13, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource14, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource15, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOF, &GPIO_InitStructure);
/* GPIOG configuration */
GPIO_PinAFConfig(GPIOG, GPIO_PinSource0 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource1 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource4 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource5 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource8 , GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOG, GPIO_PinSource15 , GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_8 | GPIO_Pin_15;
GPIO_Init(GPIOG, &GPIO_InitStructure);
/* GPIOH configuration */
GPIO_PinAFConfig(GPIOH, GPIO_PinSource3, GPIO_AF_FMC);
GPIO_PinAFConfig(GPIOH, GPIO_PinSource5, GPIO_AF_FMC);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_5;
GPIO_Init(GPIOH, &GPIO_InitStructure);
}
void SDRAM_InitSequence(void)
{
FMC_SDRAMCommandTypeDef FMC_SDRAMCommandStructure;
uint32_t tmpr = 0;
/* Step 3 --------------------------------------------------------------------*/
/* Configure a clock configuration enable command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_CLK_Enabled;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 4 --------------------------------------------------------------------*/
/* Insert 100 ms delay */
delay_ms(100);
/* Step 5 --------------------------------------------------------------------*/
/* Configure a PALL (precharge all) command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_PALL;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 6 --------------------------------------------------------------------*/
/* Configure a Auto-Refresh command */
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_AutoRefresh;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 4;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = 0;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the first command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the second command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 7 --------------------------------------------------------------------*/
/* Program the external memory mode register */
tmpr = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_2 |
SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL |
SDRAM_MODEREG_CAS_LATENCY_3 |
SDRAM_MODEREG_OPERATING_MODE_STANDARD |
SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
/* Configure a load Mode register command*/
FMC_SDRAMCommandStructure.FMC_CommandMode = FMC_Command_Mode_LoadMode;
FMC_SDRAMCommandStructure.FMC_CommandTarget = FMC_Command_Target_bank1;
FMC_SDRAMCommandStructure.FMC_AutoRefreshNumber = 1;
FMC_SDRAMCommandStructure.FMC_ModeRegisterDefinition = tmpr;
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
/* Send the command */
FMC_SDRAMCmdConfig(&FMC_SDRAMCommandStructure);
/* Step 8 --------------------------------------------------------------------*/
/* Set the refresh rate counter */
/* (15.62 us x Freq) - 20 */
/* Set the device refresh counter */
FMC_SetRefreshCount(683);//904
/* Wait until the SDRAM controller is ready */
while(FMC_GetFlagStatus(FMC_Bank1_SDRAM, FMC_FLAG_Busy) != RESET) {
}
}
void SDRAM_Init(void)
{
//delay funcion needed
delaysInit();
// Clocks must be enabled here, because the sdramInit is called before main
RCC_AHB1PeriphClockCmd(SDRAM_RCC_AHB1Periph, ENABLE);
RCC_AHB3PeriphClockCmd(SDRAM_RCC_AHB3Periph, ENABLE);
/* GPIO configuration for FMC SDRAM bank */
SDRAM_GPIOConfig();
/* FMC Configuration ---------------------------------------------------------*/
FMC_SDRAMInitTypeDef FMC_SDRAMInitStructure;
FMC_SDRAMTimingInitTypeDef FMC_SDRAMTimingInitStructure;
/* FMC SDRAM Bank configuration */
/* Timing configuration for 90 Mhz of SD clock frequency (168Mhz/2) */
/* TMRD: 2 Clock cycles */
FMC_SDRAMTimingInitStructure.FMC_LoadToActiveDelay = 2;
/* TXSR: min=70ns (7x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_ExitSelfRefreshDelay = 7;
/* TRAS: min=42ns (4x11.11ns) max=120k (ns) */
FMC_SDRAMTimingInitStructure.FMC_SelfRefreshTime = 4;
/* TRC: min=70 (7x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_RowCycleDelay = 7;
/* TWR: min=1+ 7ns (1+1x11.11ns) */
FMC_SDRAMTimingInitStructure.FMC_WriteRecoveryTime = 2;
/* TRP: 20ns => 2x11.11ns */
FMC_SDRAMTimingInitStructure.FMC_RPDelay = 2;
/* TRCD: 20ns => 2x11.11ns */
FMC_SDRAMTimingInitStructure.FMC_RCDDelay = 2;
/* FMC SDRAM control configuration */
FMC_SDRAMInitStructure.FMC_Bank = FMC_Bank1_SDRAM;
/* Row addressing: [7:0] */
FMC_SDRAMInitStructure.FMC_ColumnBitsNumber = FMC_ColumnBits_Number_8b;
/* Column addressing: [11:0] */
FMC_SDRAMInitStructure.FMC_RowBitsNumber = FMC_RowBits_Number_12b;
FMC_SDRAMInitStructure.FMC_SDMemoryDataWidth = FMC_SDMemory_Width_16b;
FMC_SDRAMInitStructure.FMC_InternalBankNumber = FMC_InternalBank_Number_4;
FMC_SDRAMInitStructure.FMC_CASLatency = FMC_CAS_Latency_3;
FMC_SDRAMInitStructure.FMC_WriteProtection = FMC_Write_Protection_Disable;
FMC_SDRAMInitStructure.FMC_SDClockPeriod = FMC_SDClock_Period_2;
FMC_SDRAMInitStructure.FMC_ReadBurst = FMC_Read_Burst_Enable;
FMC_SDRAMInitStructure.FMC_ReadPipeDelay = FMC_ReadPipe_Delay_1;
FMC_SDRAMInitStructure.FMC_SDRAMTimingStruct = &FMC_SDRAMTimingInitStructure;
/* FMC SDRAM bank initialization */
FMC_SDRAMInit(&FMC_SDRAMInitStructure);
/* FMC SDRAM device initialization sequence */
SDRAM_InitSequence();
}
radio/src/targets/pl18/touch_driver.cpp
+7 -43
View File
@@ -19,6 +19,8 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_hal_ll.h"
#include "stm32_hal.h"
#include "stm32_i2c_driver.h"
@@ -108,49 +110,11 @@ static void _touch_exti_isr(void)
touchEventOccured = true;
}
static void _touch_exti_stop(void)
{
stm32_exti_disable(TOUCH_INT_EXTI_Line);
}
static void _touch_exti_config(void)
{
__HAL_RCC_SYSCFG_CLK_ENABLE();
LL_SYSCFG_SetEXTISource(TOUCH_INT_EXTI_Port, TOUCH_INT_EXTI_SysCfgLine);
stm32_exti_enable(TOUCH_INT_EXTI_Line, LL_EXTI_TRIGGER_FALLING, _touch_exti_isr);
}
static void _touch_gpio_config(void)
{
LL_GPIO_InitTypeDef gpioInit;
LL_GPIO_StructInit(&gpioInit);
stm32_gpio_enable_clock(TOUCH_RST_GPIO);
stm32_gpio_enable_clock(TOUCH_INT_GPIO);
gpioInit.Mode = LL_GPIO_MODE_OUTPUT;
gpioInit.Speed = LL_GPIO_SPEED_FREQ_LOW;
gpioInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
gpioInit.Pull = LL_GPIO_PULL_NO;
gpioInit.Pin = TOUCH_RST_GPIO_PIN;
LL_GPIO_Init(TOUCH_RST_GPIO, &gpioInit);
LL_GPIO_SetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN);
gpioInit.Pin = TOUCH_INT_GPIO_PIN;
gpioInit.Mode = LL_GPIO_MODE_INPUT;
gpioInit.Pull = LL_GPIO_PULL_UP;
gpioInit.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
LL_GPIO_Init(TOUCH_INT_GPIO, &gpioInit);
LL_GPIO_SetOutputPin(TOUCH_INT_GPIO, TOUCH_INT_GPIO_PIN);
}
static void _touch_reset()
{
LL_GPIO_ResetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN);
gpio_clear(TOUCH_RST_GPIO);
delay_ms(10);
LL_GPIO_SetOutputPin(TOUCH_RST_GPIO, TOUCH_RST_GPIO_PIN);
gpio_set(TOUCH_RST_GPIO);
delay_ms(300);
}
@@ -356,16 +320,16 @@ void _detect_touch_controller()
void touchPanelDeInit()
{
_touch_exti_stop();
gpio_int_disable(TOUCH_INT_GPIO);
}
bool touchPanelInit()
{
_touch_gpio_config();
gpio_init(TOUCH_RST_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
_i2c_init();
_touch_reset();
_detect_touch_controller();
_touch_exti_config();
gpio_init_int(TOUCH_INT_GPIO, GPIO_IN_PU, GPIO_FALLING, _touch_exti_isr);
tcd->printDebugInfo();
radio/src/targets/simu/simpgmspace.cpp
+2 -3
View File
@@ -114,10 +114,9 @@ uint16_t getTmr2MHz()
return simuTimerMicros() * 2;
}
// return 2ms resolution to match CoOS settings
uint64_t CoGetOSTime(void)
uint32_t timersGetMsTick(void)
{
return simuTimerMicros() / 2000;
return simuTimerMicros() / 1000;
}
void simuInit()
radio/src/targets/taranis/CMakeLists.txt
+1 -1
View File
@@ -601,7 +601,7 @@ if(PCB STREQUAL XLITE OR PCB STREQUAL XLITES OR PCBREV STREQUAL COMMANDO8)
targets/common/arm/stm32/sticks_pwm_driver.cpp)
endif()
if(PCBREV STREQUAL MT12)
if(PCBREV STREQUAL MT12 OR PCBREV STREQUAL T14)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/stm32_ws2812.cpp
radio/src/targets/taranis/backlight_driver.cpp
+17 -35
View File
@@ -19,9 +19,13 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
#include "board.h"
#if !defined(BACKLIGHT_GPIO)
#if !defined(BACKLIGHT_GPIO) && (!defined(BACKLIGHT_GPIO_1) || !defined(BACKLIGHT_GPIO_2))
// no backlight
void backlightInit() {}
void backlightEnable(uint8_t level) {}
@@ -31,15 +35,9 @@
#elif defined(PCBX9E)
void backlightInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN_1|BACKLIGHT_GPIO_PIN_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource_1, BACKLIGHT_GPIO_AF_1);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource_2, BACKLIGHT_GPIO_AF_1);
gpio_init_af(BACKLIGHT_GPIO_1, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
gpio_init_af(BACKLIGHT_GPIO_2, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
stm32_timer_enable_clock(BACKLIGHT_TIMER);
BACKLIGHT_TIMER->ARR = 100;
BACKLIGHT_TIMER->PSC = BACKLIGHT_TIMER_FREQ / 50000 - 1; // 20us * 100 = 2ms => 500Hz
BACKLIGHT_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2M_2; // PWM
@@ -74,15 +72,9 @@ uint8_t isBacklightEnabled()
#elif defined(PCBX9DP)
void backlightInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN_1 | BACKLIGHT_GPIO_PIN_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource_1, BACKLIGHT_GPIO_AF_1);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource_2, BACKLIGHT_GPIO_AF_1);
gpio_init_af(BACKLIGHT_GPIO_1, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
gpio_init_af(BACKLIGHT_GPIO_2, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
stm32_timer_enable_clock(BACKLIGHT_TIMER);
BACKLIGHT_TIMER->ARR = 100;
BACKLIGHT_TIMER->PSC = BACKLIGHT_TIMER_FREQ / 50000 - 1; // 20us * 100 = 2ms => 500Hz
BACKLIGHT_TIMER->CCMR1 = TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2M_2; // PWM
@@ -118,14 +110,9 @@ uint8_t isBacklightEnabled()
#elif defined(PCBX7) || defined(PCBXLITE) || defined(PCBX9LITE)
void backlightInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource, BACKLIGHT_GPIO_AF);
gpio_init_af(BACKLIGHT_GPIO, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
stm32_timer_enable_clock(BACKLIGHT_TIMER);
#if defined(BACKLIGHT_BDTR) // TODO perhaps it can be always done
BACKLIGHT_TIMER->BDTR = BACKLIGHT_BDTR; // Enable outputs
#endif
@@ -164,14 +151,9 @@ uint8_t isBacklightEnabled()
#else
void backlightInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = BACKLIGHT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(BACKLIGHT_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(BACKLIGHT_GPIO, BACKLIGHT_GPIO_PinSource, BACKLIGHT_GPIO_AF);
gpio_init_af(BACKLIGHT_GPIO, BACKLIGHT_GPIO_AF, GPIO_PIN_SPEED_LOW);
stm32_timer_enable_clock(BACKLIGHT_TIMER);
BACKLIGHT_TIMER->ARR = 100;
BACKLIGHT_TIMER->PSC = BACKLIGHT_TIMER_FREQ / 50000 - 1; // 20us * 100 = 2ms => 500Hz
BACKLIGHT_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2; // PWM
radio/src/targets/taranis/board.cpp
+35 -57
View File
@@ -19,6 +19,8 @@
* GNU General Public License for more details.
*/
#include "stm32_hal_ll.h"
#include "stm32_gpio.h"
#include "stm32_ws2812.h"
#include "hal/adc_driver.h"
@@ -27,6 +29,7 @@
#include "hal/module_port.h"
#include "hal/abnormal_reboot.h"
#include "hal/usb_driver.h"
#include "hal/gpio.h"
#include "board.h"
#include "boards/generic_stm32/module_ports.h"
@@ -66,35 +69,8 @@ HardwareOptions hardwareOptions;
void boardInit()
{
RCC_AHB1PeriphClockCmd(PWR_RCC_AHB1Periph |
PCBREV_RCC_AHB1Periph |
LCD_RCC_AHB1Periph |
AUDIO_RCC_AHB1Periph |
BACKLIGHT_RCC_AHB1Periph |
HAPTIC_RCC_AHB1Periph |
INTMODULE_RCC_AHB1Periph |
EXTMODULE_RCC_AHB1Periph |
TELEMETRY_RCC_AHB1Periph |
SPORT_UPDATE_RCC_AHB1Periph |
BT_RCC_AHB1Periph |
USB_CHARGER_RCC_AHB1Periph,
ENABLE);
RCC_APB1PeriphClockCmd(ROTARY_ENCODER_RCC_APB1Periph |
LCD_RCC_APB1Periph |
AUDIO_RCC_APB1Periph |
BACKLIGHT_RCC_APB1Periph |
HAPTIC_RCC_APB1Periph |
TELEMETRY_RCC_APB1Periph |
BT_RCC_APB1Periph,
ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG |
BACKLIGHT_RCC_APB2Periph |
HAPTIC_RCC_APB2Periph |
BT_RCC_APB2Periph |
TELEMETRY_RCC_APB2Periph,
ENABLE);
LL_APB1_GRP1_EnableClock(AUDIO_RCC_APB1Periph);
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SYSCFG);
#if defined(BLUETOOTH) && !defined(PCBX9E)
bluetoothInit(BLUETOOTH_DEFAULT_BAUDRATE, true);
@@ -229,7 +205,9 @@ void boardInit()
#endif
#if defined(DEBUG)
DBGMCU_APB1PeriphConfig(DBGMCU_IWDG_STOP|DBGMCU_TIM1_STOP|DBGMCU_TIM2_STOP|DBGMCU_TIM3_STOP|DBGMCU_TIM6_STOP|DBGMCU_TIM8_STOP|DBGMCU_TIM10_STOP|DBGMCU_TIM13_STOP|DBGMCU_TIM14_STOP, ENABLE);
// Freeze timers & watchdog when core is halted
DBGMCU->APB1FZ = 0x00E009FF;
DBGMCU->APB2FZ = 0x00070003;
#endif
#if defined(PWR_BUTTON_PRESS)
@@ -322,61 +300,61 @@ void boardOff()
#if defined(AUDIO_SPEAKER_ENABLE_GPIO)
void initSpeakerEnable()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = AUDIO_SPEAKER_ENABLE_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(AUDIO_SPEAKER_ENABLE_GPIO, &GPIO_InitStructure);
gpio_init(AUDIO_SPEAKER_ENABLE_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
}
void enableSpeaker()
{
GPIO_SetBits(AUDIO_SPEAKER_ENABLE_GPIO, AUDIO_SPEAKER_ENABLE_GPIO_PIN);
gpio_set(AUDIO_SPEAKER_ENABLE_GPIO);
}
void disableSpeaker()
{
GPIO_ResetBits(AUDIO_SPEAKER_ENABLE_GPIO, AUDIO_SPEAKER_ENABLE_GPIO_PIN);
gpio_clear(AUDIO_SPEAKER_ENABLE_GPIO);
}
#endif
#if defined(HEADPHONE_TRAINER_SWITCH_GPIO)
void initHeadphoneTrainerSwitch()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = HEADPHONE_TRAINER_SWITCH_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(HEADPHONE_TRAINER_SWITCH_GPIO, &GPIO_InitStructure);
gpio_init(HEADPHONE_TRAINER_SWITCH_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
}
void enableHeadphone()
{
GPIO_ResetBits(HEADPHONE_TRAINER_SWITCH_GPIO, HEADPHONE_TRAINER_SWITCH_GPIO_PIN);
gpio_clear(HEADPHONE_TRAINER_SWITCH_GPIO);
}
void enableTrainer()
{
GPIO_SetBits(HEADPHONE_TRAINER_SWITCH_GPIO, HEADPHONE_TRAINER_SWITCH_GPIO_PIN);
gpio_set(HEADPHONE_TRAINER_SWITCH_GPIO);
}
#endif
#if defined(JACK_DETECT_GPIO)
void initJackDetect(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
gpio_init(JACK_DETECT_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
}
GPIO_InitStructure.GPIO_Pin = JACK_DETECT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(JACK_DETECT_GPIO, &GPIO_InitStructure);
bool isJackPlugged()
{
// debounce
static bool debounced_state = 0;
static bool last_state = 0;
if (gpio_read(JACK_DETECT_GPIO)) {
if (!last_state) {
debounced_state = false;
}
last_state = false;
}
else {
if (last_state) {
debounced_state = true;
}
last_state = true;
}
return debounced_state;
}
#endif
radio/src/targets/taranis/board.h
+3 -3
View File
@@ -68,8 +68,8 @@ uint32_t isFirmwareStart(const uint8_t * buffer);
uint32_t isBootloaderStart(const uint8_t * buffer);
// Pulses driver
#define INTERNAL_MODULE_ON() GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define INTERNAL_MODULE_OFF() GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define INTERNAL_MODULE_ON() gpio_set(INTMODULE_PWR_GPIO)
#define INTERNAL_MODULE_OFF() gpio_clear(INTMODULE_PWR_GPIO)
#if (defined(INTERNAL_MODULE_PXX1) || defined(INTERNAL_MODULE_PXX2)) && (!defined(PCBX9LITE) || defined(PCBX9LITES))
#define HARDWARE_INTERNAL_RAS
@@ -83,7 +83,7 @@ uint32_t isBootloaderStart(const uint8_t * buffer);
#if defined(TRAINER_DETECT_GPIO)
// Trainer detect is a switch on the jack
#define TRAINER_CONNECTED() (GPIO_ReadInputDataBit(TRAINER_DETECT_GPIO, TRAINER_DETECT_GPIO_PIN) == TRAINER_DETECT_GPIO_PIN_VALUE)
#define TRAINER_CONNECTED() (gpio_read(TRAINER_DETECT_GPIO) == TRAINER_DETECT_GPIO_PIN_VALUE)
#elif defined(PCBXLITES)
// Trainer is on the same connector than Headphones
enum JackState
radio/src/targets/taranis/dwt.h
+2
View File
@@ -1,3 +1,4 @@
#if 0
/*
* Copyright (C) EdgeTX
*
@@ -160,4 +161,5 @@ typedef struct
#define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */
#define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */
#endif
radio/src/targets/taranis/hal.h
+379 -710
View File
File diff suppressed because it is too large Load Diff
radio/src/targets/taranis/haptic_driver.cpp
+9 -18
View File
@@ -19,6 +19,10 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_timer.h"
#include "board.h"
#if defined(HAPTIC_PWM)
@@ -38,16 +42,9 @@ void hapticOn(uint32_t pwmPercent)
void hapticInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = HAPTIC_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(HAPTIC_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(HAPTIC_GPIO, HAPTIC_GPIO_PinSource, HAPTIC_GPIO_AF);
gpio_init_af(HAPTIC_GPIO, HAPTIC_GPIO_AF, GPIO_PIN_SPEED_LOW);
stm32_timer_enable_clock(HAPTIC_TIMER);
HAPTIC_TIMER->ARR = 100;
HAPTIC_TIMER->PSC = HAPTIC_TIMER_FREQ / 10000 - 1;
#if defined(HAPTIC_CCMR1)
@@ -67,23 +64,17 @@ void hapticInit()
// No PWM before X9D+
void hapticInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = HAPTIC_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(HAPTIC_GPIO, &GPIO_InitStructure);
gpio_init(HAPTIC_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
}
void hapticOff()
{
GPIO_ResetBits(HAPTIC_GPIO, HAPTIC_GPIO_PIN);
gpio_clear(HAPTIC_GPIO);
}
void hapticOn()
{
GPIO_SetBits(HAPTIC_GPIO, HAPTIC_GPIO_PIN);
gpio_set(HAPTIC_GPIO);
}
#endif
radio/src/targets/taranis/lcd_driver_aspi.cpp
+21 -33
View File
@@ -19,6 +19,9 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "board.h"
#include "lcd.h"
#include "hal/abnormal_reboot.h"
@@ -34,20 +37,20 @@
bool lcdInitFinished = false;
void lcdInitFinish();
#define LCD_NCS_HIGH() LCD_NCS_GPIO->BSRRL = LCD_NCS_GPIO_PIN
#define LCD_NCS_LOW() LCD_NCS_GPIO->BSRRH = LCD_NCS_GPIO_PIN
#define LCD_NCS_HIGH() gpio_set(LCD_NCS_GPIO)
#define LCD_NCS_LOW() gpio_clear(LCD_NCS_GPIO)
#define LCD_A0_HIGH() LCD_SPI_GPIO->BSRRL = LCD_A0_GPIO_PIN
#define LCD_A0_LOW() LCD_SPI_GPIO->BSRRH = LCD_A0_GPIO_PIN
#define LCD_A0_HIGH() gpio_set(LCD_A0_GPIO)
#define LCD_A0_LOW() gpio_clear(LCD_A0_GPIO)
#define LCD_RST_HIGH() LCD_RST_GPIO->BSRRL = LCD_RST_GPIO_PIN
#define LCD_RST_LOW() LCD_RST_GPIO->BSRRH = LCD_RST_GPIO_PIN
#define LCD_RST_HIGH() gpio_set(LCD_RST_GPIO)
#define LCD_RST_LOW() gpio_clear(LCD_RST_GPIO)
#define LCD_CLK_HIGH() LCD_SPI_GPIO->BSRRL = LCD_CLK_GPIO_PIN
#define LCD_CLK_LOW() LCD_SPI_GPIO->BSRRH = LCD_CLK_GPIO_PIN
#define LCD_CLK_HIGH() gpio_set(LCD_CLK_GPIO)
#define LCD_CLK_LOW() gpio_clear(LCD_CLK_GPIO)
#define LCD_MOSI_HIGH() LCD_SPI_GPIO->BSRRL = LCD_MOSI_GPIO_PIN
#define LCD_MOSI_LOW() LCD_SPI_GPIO->BSRRH = LCD_MOSI_GPIO_PIN
#define LCD_MOSI_HIGH() gpio_set(LCD_MOSI_GPIO)
#define LCD_MOSI_LOW() gpio_clear(LCD_MOSI_GPIO)
void lcdWriteCommand(uint8_t command)
{
@@ -198,29 +201,14 @@ void lcdRefresh()
void lcdHardwareInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
// Configure CLK, MOSI and A0 pins in output push-pull mode
GPIO_InitStructure.GPIO_Pin = LCD_MOSI_GPIO_PIN | LCD_CLK_GPIO_PIN | LCD_A0_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(LCD_SPI_GPIO, &GPIO_InitStructure);
gpio_init(LCD_MOSI_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_CLK_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_A0_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(LCD_NCS_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
LCD_NCS_HIGH();
// Configure NCS pin in output push-pull mode with PULLUP
GPIO_InitStructure.GPIO_Pin = LCD_NCS_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LCD_NCS_GPIO, &GPIO_InitStructure);
// Configure RST pin in output push-pull mode with PULLUP
GPIO_InitStructure.GPIO_Pin = LCD_RST_GPIO_PIN;
GPIO_Init(LCD_RST_GPIO, &GPIO_InitStructure);
gpio_init(LCD_RST_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
}
/*
@@ -233,14 +221,14 @@ void lcdOff()
LCD Sleep mode is also good for draining capacitors and enables us
to re-init LCD without any delay
*/
lcdWriteCommand(0xAE); //LCD sleep
delay_ms(3); //wait for caps to drain
lcdWriteCommand(0xAE); // LCD sleep
delay_ms(3); // wait for caps to drain
}
void lcdReset()
{
LCD_RST_LOW();
delay_ms(1); // only 3 us needed according to data-sheet, we use 1 ms
delay_ms(1); // only 3 us needed according to data-sheet, we use 1 ms
LCD_RST_HIGH();
}
radio/src/targets/taranis/lcd_driver_spi.cpp
+16 -27
View File
@@ -19,6 +19,10 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "stm32_spi.h"
#include "board.h"
#include "debug.h"
#include "lcd.h"
@@ -39,14 +43,14 @@
#define RESET_WAIT_DELAY_MS 300 // Wait time after LCD reset before first command
#define WAIT_FOR_DMA_END() do { } while (lcd_busy)
#define LCD_NCS_HIGH() LCD_NCS_GPIO->BSRRL = LCD_NCS_GPIO_PIN
#define LCD_NCS_LOW() LCD_NCS_GPIO->BSRRH = LCD_NCS_GPIO_PIN
#define LCD_NCS_HIGH() gpio_set(LCD_NCS_GPIO)
#define LCD_NCS_LOW() gpio_clear(LCD_NCS_GPIO)
#define LCD_A0_HIGH() LCD_SPI_GPIO->BSRRL = LCD_A0_GPIO_PIN
#define LCD_A0_LOW() LCD_SPI_GPIO->BSRRH = LCD_A0_GPIO_PIN
#define LCD_A0_HIGH() gpio_set(LCD_A0_GPIO)
#define LCD_A0_LOW() gpio_clear(LCD_A0_GPIO)
#define LCD_RST_HIGH() LCD_RST_GPIO->BSRRL = LCD_RST_GPIO_PIN
#define LCD_RST_LOW() LCD_RST_GPIO->BSRRH = LCD_RST_GPIO_PIN
#define LCD_RST_HIGH() gpio_set(LCD_RST_GPIO)
#define LCD_RST_LOW() gpio_clear(LCD_RST_GPIO)
bool lcdInitFinished = false;
void lcdInitFinish();
@@ -68,7 +72,9 @@ void lcdWriteCommand(uint8_t byte)
void lcdHardwareInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
stm32_spi_enable_clock(LCD_SPI);
gpio_init_af(LCD_MOSI_GPIO, LCD_GPIO_AF, GPIO_PIN_SPEED_HIGH);
gpio_init_af(LCD_CLK_GPIO, LCD_GPIO_AF, GPIO_PIN_SPEED_HIGH);
// APB1 clock / 2 = 133nS per clock
LCD_SPI->CR1 = 0; // Clear any mode error
@@ -77,28 +83,11 @@ void lcdHardwareInit()
LCD_SPI->CR1 |= SPI_CR1_MSTR; // Make sure in case SSM/SSI needed to be set first
LCD_SPI->CR1 |= SPI_CR1_SPE;
gpio_init(LCD_NCS_GPIO, GPIO_OUT, GPIO_PIN_SPEED_MEDIUM);
LCD_NCS_HIGH();
GPIO_InitStructure.GPIO_Pin = LCD_NCS_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(LCD_NCS_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = LCD_RST_GPIO_PIN;
GPIO_Init(LCD_RST_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = LCD_A0_GPIO_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(LCD_SPI_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = LCD_CLK_GPIO_PIN | LCD_MOSI_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(LCD_SPI_GPIO, &GPIO_InitStructure);
GPIO_PinAFConfig(LCD_SPI_GPIO, LCD_MOSI_GPIO_PinSource, LCD_GPIO_AF);
GPIO_PinAFConfig(LCD_SPI_GPIO, LCD_CLK_GPIO_PinSource, LCD_GPIO_AF);
gpio_init(LCD_RST_GPIO, GPIO_OUT, GPIO_PIN_SPEED_MEDIUM);
gpio_init(LCD_A0_GPIO, GPIO_OUT, GPIO_PIN_SPEED_HIGH);
LCD_DMA_Stream->CR &= ~DMA_SxCR_EN; // Disable DMA
LCD_DMA->HIFCR = LCD_DMA_FLAGS; // Write ones to clear bits
radio/src/targets/taranis/led_driver.cpp
+24 -32
View File
@@ -19,73 +19,65 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "board.h"
#if defined(FUNCTION_SWITCHES)
static const uint32_t fsLeds[] = {FSLED_GPIO_PIN_1, FSLED_GPIO_PIN_2,
FSLED_GPIO_PIN_3, FSLED_GPIO_PIN_4,
FSLED_GPIO_PIN_5, FSLED_GPIO_PIN_6};
#endif
void ledInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
#if defined(LED_GREEN_GPIO)
GPIO_InitStructure.GPIO_Pin = LED_GREEN_GPIO_PIN;
GPIO_Init(LED_GREEN_GPIO, &GPIO_InitStructure);
gpio_init(LED_GREEN_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
#if defined(LED_RED_GPIO)
GPIO_InitStructure.GPIO_Pin = LED_RED_GPIO_PIN;
GPIO_Init(LED_RED_GPIO, &GPIO_InitStructure);
gpio_init(LED_RED_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
#if defined(LED_BLUE_GPIO)
GPIO_InitStructure.GPIO_Pin = LED_BLUE_GPIO_PIN;
GPIO_Init(LED_BLUE_GPIO, &GPIO_InitStructure);
gpio_init(LED_BLUE_GPIO, GPIO_OUT, GPIO_PIN_SPEED_LOW);
#endif
#if defined(FUNCTION_SWITCHES)
RCC_AHB1PeriphClockCmd(FS_RCC_AHB1Periph, ENABLE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = FSLED_GPIO_PIN_1 | FSLED_GPIO_PIN_2 | FSLED_GPIO_PIN_3 | FSLED_GPIO_PIN_4 | FSLED_GPIO_PIN_5 | FSLED_GPIO_PIN_6;
GPIO_Init(FSLED_GPIO, &GPIO_InitStructure);
for (int i = 0; i < DIM(fsLeds); i++) {
gpio_init(fsLeds[i], GPIO_OUT, GPIO_PIN_SPEED_LOW);
}
#endif
}
#if defined(FUNCTION_SWITCHES)
constexpr uint32_t fsLeds[] = {FSLED_GPIO_PIN_1, FSLED_GPIO_PIN_2,
FSLED_GPIO_PIN_3, FSLED_GPIO_PIN_4,
FSLED_GPIO_PIN_5, FSLED_GPIO_PIN_6};
void fsLedOff(uint8_t index)
{
GPIO_FSLED_GPIO_OFF(FSLED_GPIO, fsLeds[index]);
gpio_clear(fsLeds[index]);
}
void fsLedOn(uint8_t index)
{
GPIO_FSLED_GPIO_ON(FSLED_GPIO, fsLeds[index]);
gpio_set(fsLeds[index]);
}
bool getFSLedState(uint8_t index)
{
return (FSLED_GPIO->ODR & fsLeds[index]);
return gpio_read(fsLeds[index]) ? true : false;
}
#endif
void ledOff()
{
#if defined(LED_RED_GPIO)
GPIO_LED_GPIO_OFF(LED_RED_GPIO, LED_RED_GPIO_PIN);
GPIO_LED_GPIO_OFF(LED_RED_GPIO);
#endif
#if defined(LED_BLUE_GPIO)
GPIO_LED_GPIO_OFF(LED_BLUE_GPIO, LED_BLUE_GPIO_PIN);
GPIO_LED_GPIO_OFF(LED_BLUE_GPIO);
#endif
#if defined(LED_GREEN_GPIO)
GPIO_LED_GPIO_OFF(LED_GREEN_GPIO, LED_GREEN_GPIO_PIN);
GPIO_LED_GPIO_OFF(LED_GREEN_GPIO);
#endif
}
@@ -93,7 +85,7 @@ void ledRed()
{
ledOff();
#if defined(LED_RED_GPIO)
GPIO_LED_GPIO_ON(LED_RED_GPIO, LED_RED_GPIO_PIN);
GPIO_LED_GPIO_ON(LED_RED_GPIO);
#endif
}
@@ -101,7 +93,7 @@ void ledGreen()
{
ledOff();
#if defined(LED_GREEN_GPIO)
GPIO_LED_GPIO_ON(LED_GREEN_GPIO, LED_GREEN_GPIO_PIN);
GPIO_LED_GPIO_ON(LED_GREEN_GPIO);
#endif
}
@@ -109,6 +101,6 @@ void ledBlue()
{
ledOff();
#if defined(LED_BLUE_GPIO)
GPIO_LED_GPIO_ON(LED_BLUE_GPIO, LED_BLUE_GPIO_PIN);
GPIO_LED_GPIO_ON(LED_BLUE_GPIO);
#endif
}
radio/src/targets/taranis/top_lcd_driver.cpp
+19 -19
View File
@@ -19,22 +19,25 @@
* GNU General Public License for more details.
*/
#include <stdlib.h>
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "opentx.h"
#include "board.h"
#include "lcd.h"
#define CS1_HIGH() TOPLCD_GPIO->BSRRL = TOPLCD_GPIO_PIN_CS1
#define CS1_LOW() TOPLCD_GPIO->BSRRH = TOPLCD_GPIO_PIN_CS1
#define CS2_HIGH() TOPLCD_GPIO->BSRRL = TOPLCD_GPIO_PIN_CS2
#define CS2_LOW() TOPLCD_GPIO->BSRRH = TOPLCD_GPIO_PIN_CS2
#define WR_HIGH() TOPLCD_GPIO->BSRRL = TOPLCD_GPIO_PIN_WR
#define WR_LOW() TOPLCD_GPIO->BSRRH = TOPLCD_GPIO_PIN_WR
#define DATA_HIGH() TOPLCD_GPIO->BSRRL = TOPLCD_GPIO_PIN_DATA
#define DATA_LOW() TOPLCD_GPIO->BSRRH = TOPLCD_GPIO_PIN_DATA
#define BL_ON() TOPLCD_GPIO->BSRRL = TOPLCD_GPIO_PIN_BL
#define BL_OFF() TOPLCD_GPIO->BSRRH = TOPLCD_GPIO_PIN_BL
#include <stdlib.h>
#define CS1_HIGH() gpio_set(TOPLCD_GPIO_CS1)
#define CS1_LOW() gpio_clear(TOPLCD_GPIO_CS1)
#define CS2_HIGH() gpio_set(TOPLCD_GPIO_CS2)
#define CS2_LOW() gpio_clear(TOPLCD_GPIO_CS2)
#define WR_HIGH() gpio_set(TOPLCD_GPIO_WR)
#define WR_LOW() gpio_clear(TOPLCD_GPIO_WR)
#define DATA_HIGH() gpio_set(TOPLCD_GPIO_DATA)
#define DATA_LOW() gpio_clear(TOPLCD_GPIO_DATA)
#define BL_ON() gpio_set(TOPLCD_GPIO_BL)
#define BL_OFF() gpio_clear(TOPLCD_GPIO_BL)
const uint8_t TimeLCDsegs[] = { 0xAF, 0x06, 0x6D, 0x4F, 0xC6, 0xCB, 0xEB, 0x0E, 0xEF, 0xCF };
const uint8_t RssiLCDsegs[] = { 0xFA, 0x60, 0xBC, 0xF4, 0x66, 0xD6, 0xDE, 0x70, 0xFE, 0xF6 };
@@ -224,14 +227,11 @@ extern "C" void TIM8_BRK_TIM12_IRQHandler()
void toplcdInit()
{
RCC_AHB1PeriphClockCmd(TOPLCD_RCC_AHB1Periph, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = TOPLCD_GPIO_PIN_DATA | TOPLCD_GPIO_PIN_WR |TOPLCD_GPIO_PIN_BL|TOPLCD_GPIO_PIN_CS1|TOPLCD_GPIO_PIN_CS2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(TOPLCD_GPIO, &GPIO_InitStructure);
gpio_init(TOPLCD_GPIO_DATA, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(TOPLCD_GPIO_WR, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(TOPLCD_GPIO_CS1, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(TOPLCD_GPIO_CS2, GPIO_OUT, GPIO_PIN_SPEED_LOW);
gpio_init(TOPLCD_GPIO_BL, GPIO_OUT, GPIO_PIN_SPEED_LOW);
BL_ON();
radio/src/targets/taranis/usb_charger_driver.cpp
+5 -12
View File
@@ -19,25 +19,18 @@
* GNU General Public License for more details.
*/
#include "hal/gpio.h"
#include "stm32_gpio.h"
#include "board.h"
#include "hal/usb_driver.h"
void usbChargerInit()
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = USB_CHARGER_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(USB_CHARGER_GPIO, &GPIO_InitStructure);
gpio_init(USB_CHARGER_GPIO, GPIO_IN_PU, GPIO_PIN_SPEED_LOW);
}
bool usbChargerLed()
{
#if defined(SIMU)
return true;
#else
return (GPIO_ReadInputDataBit(USB_CHARGER_GPIO, USB_CHARGER_GPIO_PIN) == Bit_RESET && usbPlugged());
#endif
return (!gpio_read(USB_CHARGER_GPIO) && usbPlugged());
}
radio/src/thirdparty/STM32F2xx_StdPeriph_Lib_V1.1.0/Libraries/CMSIS/Device/ST/STM32F2xx/Include/stm32f2xx.h
Vendored
-6967
View File
File diff suppressed because it is too large Load Diff
radio/src/thirdparty/STM32F2xx_StdPeriph_Lib_V1.1.0/Libraries/CMSIS/Device/ST/STM32F2xx/Include/system_stm32f2xx.h
Vendored
-105
View File
@@ -1,105 +0,0 @@
/**
******************************************************************************
* @file system_stm32f2xx.h
* @author MCD Application Team
* @version V1.1.3
* @date 05-March-2012
* @brief CMSIS Cortex-M3 Device Peripheral Access Layer System Header File.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2012 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.st.com/software_license_agreement_liberty_v2
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************
*/
/** @addtogroup CMSIS
* @{
*/
/** @addtogroup stm32f2xx_system
* @{
*/
/**
* @brief Define to prevent recursive inclusion
*/
#ifndef __SYSTEM_STM32F2XX_H
#define __SYSTEM_STM32F2XX_H
#ifdef __cplusplus
extern "C" {
#endif
/** @addtogroup STM32F2xx_System_Includes
* @{
*/
/**
* @}
*/
/** @addtogroup STM32F2xx_System_Exported_types
* @{
*/
extern uint32_t SystemCoreClock; /*!< System Clock Frequency (Core Clock) */
/**
* @}
*/
/** @addtogroup STM32F2xx_System_Exported_Constants
* @{
*/
/**
* @}
*/
/** @addtogroup STM32F2xx_System_Exported_Macros
* @{
*/
/**
* @}
*/
/** @addtogroup STM32F2xx_System_Exported_Functions
* @{
*/
extern void SystemInit(void);
extern void SystemCoreClockUpdate(void);
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /*__SYSTEM_STM32F2XX_H */
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
radio/src/thirdparty/STM32F2xx_StdPeriph_Lib_V1.1.0/Libraries/CMSIS/Include/arm_common_tables.h
Vendored
-35
View File
@@ -1,35 +0,0 @@
/* ----------------------------------------------------------------------
* Copyright (C) 2010 ARM Limited. All rights reserved.
*
* $Date: 11. November 2010
* $Revision: V1.0.2
*
* Project: CMSIS DSP Library
* Title: arm_common_tables.h
*
* Description: This file has extern declaration for common tables like Bitreverse, reciprocal etc which are used across different functions
*
* Target Processor: Cortex-M4/Cortex-M3
*
* Version 1.0.2 2010/11/11
* Documentation updated.
*
* Version 1.0.1 2010/10/05
* Production release and review comments incorporated.
*
* Version 1.0.0 2010/09/20
* Production release and review comments incorporated.
* -------------------------------------------------------------------- */
#ifndef _ARM_COMMON_TABLES_H
#define _ARM_COMMON_TABLES_H
#include "arm_math.h"
extern uint16_t armBitRevTable[256];
extern q15_t armRecipTableQ15[64];
extern q31_t armRecipTableQ31[64];
extern const q31_t realCoefAQ31[1024];
extern const q31_t realCoefBQ31[1024];
#endif /* ARM_COMMON_TABLES_H */
radio/src/thirdparty/STM32F2xx_StdPeriph_Lib_V1.1.0/Libraries/CMSIS/Include/arm_math.h
Vendored
-7051
View File
File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More