try soft UART EXTI and timer
This commit is contained in:
parent
6b355b0bb3
commit
f9b46124a0
261
lib/uart_soft.c
261
lib/uart_soft.c
|
|
@ -12,11 +12,11 @@
|
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
/** library to control multiple software USARTs (code)
|
||||
* @file usart_soft.c
|
||||
/** library to control multiple software UARTs (code)
|
||||
* @file uart_soft.c
|
||||
* @author King Kévin <kingkevin@cuvoodoo.info>
|
||||
* @date 2016
|
||||
* @note peripherals used: GPIO @ref usart_soft_gpio, timer @ref usart_soft_timer
|
||||
* @note peripherals used: GPIO @ref uart_soft_gpio, timer @ref uart_soft_timer
|
||||
*/
|
||||
|
||||
/* standard libraries */
|
||||
|
|
@ -28,161 +28,185 @@
|
|||
#include <libopencm3/stm32/gpio.h> // general purpose input output library
|
||||
#include <libopencm3/stm32/timer.h> // timer library
|
||||
#include <libopencm3/cm3/nvic.h> // interrupt handler
|
||||
#include <libopencm3/stm32/exti.h> // external interrupt defines
|
||||
|
||||
#include "usart_soft.h" // software USART library API
|
||||
#include "uart_soft.h" // software UART library API
|
||||
#include "global.h" // common methods
|
||||
|
||||
/** @defgroup usart_soft_gpio GPIO used for the software USART ports
|
||||
/** @defgroup uart_soft_gpio GPIO used for the software UART ports
|
||||
* @note up to 4 pins supported, comment if unused
|
||||
* @warning only one port must be used per line (pin number)
|
||||
* @{
|
||||
*/
|
||||
#define USART_SOFT_RX_PORT0 A
|
||||
#define USART_SOFT_RX_PIN0 0
|
||||
#define USART_SOFT_RX_PORT1 A
|
||||
#define USART_SOFT_RX_PIN1 0
|
||||
#define USART_SOFT_RX_PORT2 A
|
||||
#define USART_SOFT_RX_PIN2 0
|
||||
#define USART_SOFT_RX_PORT3 A
|
||||
#define USART_SOFT_RX_PIN3 0
|
||||
#define USART_SOFT_TX_PORT0 A
|
||||
#define USART_SOFT_TX_PIN0 0
|
||||
#define USART_SOFT_TX_PORT1 A
|
||||
#define USART_SOFT_TX_PIN1 0
|
||||
#define USART_SOFT_TX_PORT2 A
|
||||
#define USART_SOFT_TX_PIN2 0
|
||||
#define USART_SOFT_TX_PORT3 A
|
||||
#define USART_SOFT_TX_PIN3 0
|
||||
#define UART_SOFT_RX_PORT0 B
|
||||
#define UART_SOFT_RX_PIN0 9
|
||||
//#define UART_SOFT_RX_PORT1 A
|
||||
//#define UART_SOFT_RX_PIN1 0
|
||||
//#define UART_SOFT_RX_PORT2 A
|
||||
//#define UART_SOFT_RX_PIN2 0
|
||||
//#define UART_SOFT_RX_PORT3 A
|
||||
//#define UART_SOFT_RX_PIN3 0
|
||||
//#define UART_SOFT_TX_PORT0 A
|
||||
//#define UART_SOFT_TX_PIN0 0
|
||||
//#define UART_SOFT_TX_PORT1 A
|
||||
//#define UART_SOFT_TX_PIN1 0
|
||||
//#define UART_SOFT_TX_PORT2 A
|
||||
//#define UART_SOFT_TX_PIN2 0
|
||||
//#define UART_SOFT_TX_PORT3 A
|
||||
//#define UART_SOFT_TX_PIN3 0
|
||||
/** @} */
|
||||
|
||||
/** @defgroup usart_soft_config USART configurations (2400-115200 bps)
|
||||
/** @defgroup uart_soft_config UART configurations (2400-115200 bps)
|
||||
* @note this implementation is designed for 8 bits, no parity, any stop configuration since this is the most common case
|
||||
* @{
|
||||
*/
|
||||
#define USART_SOFT_RX_BAUDRATE0 0
|
||||
#define USART_SOFT_RX_BAUDRATE1 0
|
||||
#define USART_SOFT_RX_BAUDRATE2 0
|
||||
#define USART_SOFT_RX_BAUDRATE3 0
|
||||
#define USART_SOFT_TX_BAUDRATE0 0
|
||||
#define USART_SOFT_TX_BAUDRATE1 0
|
||||
#define USART_SOFT_TX_BAUDRATE2 0
|
||||
#define USART_SOFT_TX_BAUDRATE3 0
|
||||
#define UART_SOFT_RX_BAUDRATE0 9600
|
||||
//#define UART_SOFT_RX_BAUDRATE1 0
|
||||
//#define UART_SOFT_RX_BAUDRATE2 0
|
||||
//#define UART_SOFT_RX_BAUDRATE3 0
|
||||
//#define UART_SOFT_TX_BAUDRATE0 0
|
||||
//#define UART_SOFT_TX_BAUDRATE1 0
|
||||
//#define UART_SOFT_TX_BAUDRATE2 0
|
||||
//#define UART_SOFT_TX_BAUDRATE3 0
|
||||
/** @} */
|
||||
|
||||
/** @defgroup usart_soft_timer timer used to same USART signals
|
||||
/** @defgroup uart_soft_timer timer used to same UART signals
|
||||
* @{
|
||||
*/
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0)) || (defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1)) || (defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2)) || (defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN0))
|
||||
#define USART_SOFT_RX_TIMER 3 /**< timer peripheral for receive signals */
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0)) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1)) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2)) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN0))
|
||||
#define UART_SOFT_RX_TIMER 3 /**< timer peripheral for receive signals */
|
||||
#endif
|
||||
#if (defined(USART_SOFT_TX_PORT0) && defined(USART_SOFT_TX_PIN0)) || (defined(USART_SOFT_TX_PORT1) && defined(USART_SOFT_TX_PIN1)) || (defined(USART_SOFT_TX_PORT2) && defined(USART_SOFT_TX_PIN2)) || (defined(USART_SOFT_TX_PORT3) && defined(USART_SOFT_TX_PIN0))
|
||||
#define USART_SOFT_TX_TIMER 4 /**< timer peripheral for transmit signals */
|
||||
#if (defined(UART_SOFT_TX_PORT0) && defined(UART_SOFT_TX_PIN0)) || (defined(UART_SOFT_TX_PORT1) && defined(UART_SOFT_TX_PIN1)) || (defined(UART_SOFT_TX_PORT2) && defined(UART_SOFT_TX_PIN2)) || (defined(UART_SOFT_TX_PORT3) && defined(UART_SOFT_TX_PIN0))
|
||||
#define UART_SOFT_TX_TIMER 4 /**< timer peripheral for transmit signals */
|
||||
#endif
|
||||
/** @} */
|
||||
|
||||
/** @defgroup usart_soft_state
|
||||
/** @defgroup uart_soft_state
|
||||
* @{
|
||||
*/
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0))
|
||||
volatile bool rx0_state = 0; /**< state of the GPIO */
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0))
|
||||
volatile uint16_t rx0_state = 0; /**< state of the GPIO */
|
||||
volatile uint8_t rx0_bit = 0; /**< next bit to receive */
|
||||
volatile uint8_t rx0_byte = 0; /**< byte received */
|
||||
#endif
|
||||
/** @} */
|
||||
|
||||
bool usart_soft_setup(void)
|
||||
bool uart_soft_setup(void)
|
||||
{
|
||||
// verify configuration
|
||||
#if (defined(USART_SOFT_RX_BAUDRATE0) && ((USART_SOFT_RX_BAUDRATE0<2400) || (USART_SOFT_RX_BAUDRATE0>115200)))
|
||||
#if (defined(UART_SOFT_RX_BAUDRATE0) && ((UART_SOFT_RX_BAUDRATE0<2400) || (UART_SOFT_RX_BAUDRATE0>115200)))
|
||||
return false;
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_BAUDRATE1) && ((USART_SOFT_RX_BAUDRATE1<2400) || (USART_SOFT_RX_BAUDRATE1>115200)))
|
||||
#if (defined(UART_SOFT_RX_BAUDRATE1) && ((UART_SOFT_RX_BAUDRATE1<2400) || (UART_SOFT_RX_BAUDRATE1>115200)))
|
||||
return false;
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_BAUDRATE2) && ((USART_SOFT_RX_BAUDRATE2<2400) || (USART_SOFT_RX_BAUDRATE2>115200)))
|
||||
#if (defined(UART_SOFT_RX_BAUDRATE2) && ((UART_SOFT_RX_BAUDRATE2<2400) || (UART_SOFT_RX_BAUDRATE2>115200)))
|
||||
return false;
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_BAUDRATE3) && ((USART_SOFT_RX_BAUDRATE3<2400) || (USART_SOFT_RX_BAUDRATE3>115200)))
|
||||
#if (defined(UART_SOFT_RX_BAUDRATE3) && ((UART_SOFT_RX_BAUDRATE3<2400) || (UART_SOFT_RX_BAUDRATE3>115200)))
|
||||
return false;
|
||||
#endif
|
||||
#if (defined(USART_SOFT_TX_BAUDRATE0) && ((USART_SOFT_TX_BAUDRATE0<2400) || (USART_SOFT_TX_BAUDRATE0>115200)))
|
||||
#if (defined(UART_SOFT_TX_BAUDRATE0) && ((UART_SOFT_TX_BAUDRATE0<2400) || (UART_SOFT_TX_BAUDRATE0>115200)))
|
||||
return false;
|
||||
#endif
|
||||
#if (defined(USART_SOFT_TX_BAUDRATE1) && ((USART_SOFT_TX_BAUDRATE1<2400) || (USART_SOFT_TX_BAUDRATE1>115200)))
|
||||
#if (defined(UART_SOFT_TX_BAUDRATE1) && ((UART_SOFT_TX_BAUDRATE1<2400) || (UART_SOFT_TX_BAUDRATE1>115200)))
|
||||
return false;
|
||||
#endif
|
||||
#if (defined(USART_SOFT_TX_BAUDRATE2) && ((USART_SOFT_TX_BAUDRATE2<2400) || (USART_SOFT_TX_BAUDRATE2>115200)))
|
||||
#if (defined(UART_SOFT_TX_BAUDRATE2) && ((UART_SOFT_TX_BAUDRATE2<2400) || (UART_SOFT_TX_BAUDRATE2>115200)))
|
||||
return false;
|
||||
#endif
|
||||
#if (defined(USART_SOFT_TX_BAUDRATE3) && ((USART_SOFT_TX_BAUDRATE3<2400) || (USART_SOFT_TX_BAUDRATE3>115200)))
|
||||
#if (defined(UART_SOFT_TX_BAUDRATE3) && ((UART_SOFT_TX_BAUDRATE3<2400) || (UART_SOFT_TX_BAUDRATE3>115200)))
|
||||
return false;
|
||||
#endif
|
||||
|
||||
// setup GPIOs
|
||||
#if defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0)
|
||||
rcc_periph_clock_enable(RCC_GPIO(USART_SOFT_RX_PORT0)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(USART_SOFT_RX_PORT0), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(USART_SOFT_RX_PIN0)); // setup GPIO pin USART receive
|
||||
gpio_set(GPIO(USART_SOFT_RX_PORT0), GPIO(USART_SOFT_RX_PIN0)); // pull up to avoid noise when not connected
|
||||
rx0_state = gpio_get(GPIO(USART_SOFT_RX_PORT0), GPIO(USART_SOFT_RX_PIN0)); // save state of GPIO
|
||||
#if defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0)
|
||||
rcc_periph_clock_enable(RCC_GPIO(UART_SOFT_RX_PORT0)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(UART_SOFT_RX_PORT0), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(UART_SOFT_RX_PIN0)); // setup GPIO pin UART receive
|
||||
gpio_set(GPIO(UART_SOFT_RX_PORT0), GPIO(UART_SOFT_RX_PIN0)); // pull up to avoid noise when not connected
|
||||
rcc_periph_clock_enable(RCC_AFIO); // enable alternate function clock for external interrupt
|
||||
exti_select_source(EXTI(UART_SOFT_RX_PIN0), GPIO(UART_SOFT_RX_PORT0)); // mask external interrupt of this pin only for this port
|
||||
exti_enable_request(EXTI(UART_SOFT_RX_PIN0)); // enable external interrupt
|
||||
exti_set_trigger(EXTI(UART_SOFT_RX_PIN0), EXTI_TRIGGER_BOTH); // trigger when button is pressed
|
||||
nvic_enable_irq(NVIC_EXTI_IRQ(UART_SOFT_RX_PIN0)); // enable interrupt
|
||||
rx0_state = gpio_get(GPIO(UART_SOFT_RX_PORT0), GPIO(UART_SOFT_RX_PIN0)); // save state of GPIO
|
||||
rx0_bit = 0; // reset bits received
|
||||
#endif
|
||||
#if defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1)
|
||||
rcc_periph_clock_enable(RCC_GPIO(USART_SOFT_RX_PORT1)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(USART_SOFT_RX_PORT1), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(USART_SOFT_RX_PIN1)); // setup GPIO pin USART receive
|
||||
gpio_set(GPIO(USART_SOFT_RX_PORT1), GPIO(USART_SOFT_RX_PIN1)); // pull up to avoid noise when not connected
|
||||
#if defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1)
|
||||
rcc_periph_clock_enable(RCC_GPIO(UART_SOFT_RX_PORT1)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(UART_SOFT_RX_PORT1), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(UART_SOFT_RX_PIN1)); // setup GPIO pin UART receive
|
||||
gpio_set(GPIO(UART_SOFT_RX_PORT1), GPIO(UART_SOFT_RX_PIN1)); // pull up to avoid noise when not connected
|
||||
#endif
|
||||
#if defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2)
|
||||
rcc_periph_clock_enable(RCC_GPIO(USART_SOFT_RX_PORT2)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(USART_SOFT_RX_PORT2), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(USART_SOFT_RX_PIN2)); // setup GPIO pin USART receive
|
||||
gpio_set(GPIO(USART_SOFT_RX_PORT2), GPIO(USART_SOFT_RX_PIN2)); // pull up to avoid noise when not connected
|
||||
#if defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2)
|
||||
rcc_periph_clock_enable(RCC_GPIO(UART_SOFT_RX_PORT2)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(UART_SOFT_RX_PORT2), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(UART_SOFT_RX_PIN2)); // setup GPIO pin UART receive
|
||||
gpio_set(GPIO(UART_SOFT_RX_PORT2), GPIO(UART_SOFT_RX_PIN2)); // pull up to avoid noise when not connected
|
||||
#endif
|
||||
#if defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN3)
|
||||
rcc_periph_clock_enable(RCC_GPIO(USART_SOFT_RX_PORT3)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(USART_SOFT_RX_PORT3), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(USART_SOFT_RX_PIN3)); // setup GPIO pin USART receive
|
||||
gpio_set(GPIO(USART_SOFT_RX_PORT3), GPIO(USART_SOFT_RX_PIN3)); // pull up to avoid noise when not connected
|
||||
#if defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3)
|
||||
rcc_periph_clock_enable(RCC_GPIO(UART_SOFT_RX_PORT3)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(UART_SOFT_RX_PORT3), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(UART_SOFT_RX_PIN3)); // setup GPIO pin UART receive
|
||||
gpio_set(GPIO(UART_SOFT_RX_PORT3), GPIO(UART_SOFT_RX_PIN3)); // pull up to avoid noise when not connected
|
||||
#endif
|
||||
#if defined(USART_SOFT_TX_PORT0) && defined(USART_SOFT_TX_PIN0)
|
||||
rcc_periph_clock_enable(RCC_GPIO(USART_SOFT_TX_PORT0)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(USART_SOFT_TX_PORT0), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(USART_SOFT_TX_PIN0));
|
||||
#if defined(UART_SOFT_TX_PORT0) && defined(UART_SOFT_TX_PIN0)
|
||||
rcc_periph_clock_enable(RCC_GPIO(UART_SOFT_TX_PORT0)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(UART_SOFT_TX_PORT0), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(UART_SOFT_TX_PIN0));
|
||||
#endif
|
||||
#if defined(USART_SOFT_TX_PORT1) && defined(USART_SOFT_TX_PIN1)
|
||||
rcc_periph_clock_enable(RCC_GPIO(USART_SOFT_TX_PORT1)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(USART_SOFT_TX_PORT1), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(USART_SOFT_TX_PIN1));
|
||||
#if defined(UART_SOFT_TX_PORT1) && defined(UART_SOFT_TX_PIN1)
|
||||
rcc_periph_clock_enable(RCC_GPIO(UART_SOFT_TX_PORT1)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(UART_SOFT_TX_PORT1), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(UART_SOFT_TX_PIN1));
|
||||
#endif
|
||||
#if defined(USART_SOFT_TX_PORT2) && defined(USART_SOFT_TX_PIN2)
|
||||
rcc_periph_clock_enable(RCC_GPIO(USART_SOFT_TX_PORT2)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(USART_SOFT_TX_PORT2), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(USART_SOFT_TX_PIN2));
|
||||
#if defined(UART_SOFT_TX_PORT2) && defined(UART_SOFT_TX_PIN2)
|
||||
rcc_periph_clock_enable(RCC_GPIO(UART_SOFT_TX_PORT2)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(UART_SOFT_TX_PORT2), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(UART_SOFT_TX_PIN2));
|
||||
#endif
|
||||
#if defined(USART_SOFT_TX_PORT3) && defined(USART_SOFT_TX_PIN3)
|
||||
rcc_periph_clock_enable(RCC_GPIO(USART_SOFT_TX_PORT3)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(USART_SOFT_TX_PORT3), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(USART_SOFT_TX_PIN3));
|
||||
#if defined(UART_SOFT_TX_PORT3) && defined(UART_SOFT_TX_PIN3)
|
||||
rcc_periph_clock_enable(RCC_GPIO(UART_SOFT_TX_PORT3)); // enable clock for GPIO peripheral
|
||||
gpio_set_mode(GPIO(UART_SOFT_TX_PORT3), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(UART_SOFT_TX_PIN3));
|
||||
#endif
|
||||
|
||||
// setup timer
|
||||
#if defined(USART_SOFT_RX_TIMER)
|
||||
rcc_periph_clock_enable(RCC_TIM(USART_SOFT_RX_TIMER)); // enable clock for timer peripheral
|
||||
timer_reset(TIM(USART_SOFT_RX_TIMER)); // reset timer state
|
||||
timer_set_mode(TIM(USART_SOFT_RX_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
|
||||
timer_set_prescaler(TIM(USART_SOFT_RX_TIMER), 0); // prescaler to be able to sample 2400-115200 bps (72MHz/2^16=1099<2400bps)
|
||||
nvic_enable_irq(NVIC_TIM_IRQ(USART_SOFT_RX_TIMER)); // allow interrupt for timer
|
||||
#if defined(UART_SOFT_RX_TIMER)
|
||||
rcc_periph_clock_enable(RCC_TIM(UART_SOFT_RX_TIMER)); // enable clock for timer peripheral
|
||||
timer_reset(TIM(UART_SOFT_RX_TIMER)); // reset timer state
|
||||
timer_set_mode(TIM(UART_SOFT_RX_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
|
||||
timer_set_prescaler(TIM(UART_SOFT_RX_TIMER), 0); // prescaler to be able to sample 2400-115200 bps (72MHz/2^16=1099<2400bps)
|
||||
nvic_enable_irq(NVIC_TIM_IRQ(UART_SOFT_RX_TIMER)); // allow interrupt for timer
|
||||
timer_enable_counter(TIM(UART_SOFT_RX_TIMER)); // start timer to generate interrupts for the RX pins
|
||||
#endif
|
||||
#if defined(USART_SOFT_TX_TIMER)
|
||||
rcc_periph_clock_enable(RCC_TIM(USART_SOFT_TX_TIMER)); // enable clock for timer peripheral
|
||||
timer_reset(TIM(USART_SOFT_TX_TIMER)); // reset timer state
|
||||
timer_set_mode(TIM(USART_SOFT_TX_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
|
||||
timer_set_prescaler(TIM(USART_SOFT_TX_TIMER), 0); // prescaler to be able to sample 2400-115200 bps (72MHz/2^16=1099<2400bps)
|
||||
nvic_enable_irq(NVIC_TIM_IRQ(USART_SOFT_TX_TIMER)); // allow interrupt for timer
|
||||
#if defined(UART_SOFT_TX_TIMER)
|
||||
rcc_periph_clock_enable(RCC_TIM(UART_SOFT_TX_TIMER)); // enable clock for timer peripheral
|
||||
timer_reset(TIM(UART_SOFT_TX_TIMER)); // reset timer state
|
||||
timer_set_mode(TIM(UART_SOFT_TX_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
|
||||
timer_set_prescaler(TIM(UART_SOFT_TX_TIMER), 0); // prescaler to be able to sample 2400-115200 bps (72MHz/2^16=1099<2400bps)
|
||||
nvic_enable_irq(NVIC_TIM_IRQ(UART_SOFT_TX_TIMER)); // allow interrupt for timer
|
||||
#endif
|
||||
|
||||
return true; // setup completed
|
||||
}
|
||||
|
||||
#if defined(USART_SOFT_RX_TIMER)
|
||||
void TIM_ISR(USART_SOFT_RX_TIMER)(void)
|
||||
#if defined(UART_SOFT_RX_TIMER)
|
||||
void TIM_ISR(UART_SOFT_RX_TIMER)(void)
|
||||
{
|
||||
if (timer_interrupt_source(TIM(UART_SOFT_RX_TIMER),TIM_SR_CC1IF)) { // got a match on compare 1 for RX0
|
||||
timer_clear_flag(TIM(UART_SOFT_RX_TIMER),TIM_SR_CC1IF); // clear flag
|
||||
#if defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0)
|
||||
led_toggle();
|
||||
rx0_byte += ((gpio_get(GPIO(UART_SOFT_RX_PORT0),GPIO(UART_SOFT_RX_PIN0))==0 ? 0 : 1)<<(rx0_bit-1)); // save bit value
|
||||
if (rx0_bit<8) { // not the last bit received
|
||||
timer_set_oc_value(TIM(UART_SOFT_RX_TIMER),TIM_OC1,timer_get_counter(TIM(UART_SOFT_RX_TIMER))+rcc_ahb_frequency/UART_SOFT_RX_BAUDRATE0); // set timer to next bit
|
||||
rx0_bit++; // wait for next bit
|
||||
} else { // last bit received
|
||||
// save byte
|
||||
timer_disable_irq(TIM(UART_SOFT_RX_TIMER),TIM_DIER_CC1IE); // stop_interrupting
|
||||
rx0_bit = 0; // next bit should be first bit of next byte
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(USART_SOFT_TX_TIMER)
|
||||
void TIM_ISR(USART_SOFT_TX_TIMER)(void)
|
||||
#if defined(UART_SOFT_TX_TIMER)
|
||||
void TIM_ISR(UART_SOFT_TX_TIMER)(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
|
@ -190,49 +214,72 @@ void TIM_ISR(USART_SOFT_TX_TIMER)(void)
|
|||
/** central function handling receive signal activity */
|
||||
static void rx_activity(void)
|
||||
{
|
||||
|
||||
// verify if UART pin state changed
|
||||
#if defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0)
|
||||
if (rx0_state!=gpio_get(GPIO(UART_SOFT_RX_PORT0),GPIO(UART_SOFT_RX_PIN0))) { // only do something if state changed
|
||||
rx0_state = gpio_get(GPIO(UART_SOFT_RX_PORT0),GPIO(UART_SOFT_RX_PIN0)); // save new state
|
||||
if (rx0_bit==0) { // start bit edge detected
|
||||
if (rx0_state==0) { // start bit has to be low
|
||||
timer_set_oc_value(TIM(UART_SOFT_RX_TIMER),TIM_OC1,timer_get_counter(TIM(UART_SOFT_RX_TIMER))+(rcc_ahb_frequency/UART_SOFT_RX_BAUDRATE0)*1.5); // set timer to sample data bit 0 in 1.5 bits
|
||||
timer_clear_flag(TIM(UART_SOFT_RX_TIMER),TIM_SR_CC1IF); // clear flag before enabling interrupt
|
||||
timer_enable_irq(TIM(UART_SOFT_RX_TIMER),TIM_DIER_CC1IE);// enable timer IRQ for RX0
|
||||
rx0_byte = 0; // reset byte value
|
||||
rx0_bit++; // wait for first bit
|
||||
}
|
||||
} else { // data bit detected
|
||||
timer_set_oc_value(TIM(UART_SOFT_RX_TIMER),TIM_OC1,timer_get_counter(TIM(UART_SOFT_RX_TIMER))+(rcc_ahb_frequency/UART_SOFT_RX_BAUDRATE0)/2); // resync timer to half a bit (good for drifting transmission, bad if the line is noisy)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0) && USART_SOFT_RX_PIN0==0) || (defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1) && USART_SOFT_RX_PIN1==0) || (defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2) && USART_SOFT_RX_PIN2==0) || (defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN3) && USART_SOFT_RX_PIN3==0)
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==0) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==0) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==0) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==0)
|
||||
void exti0_isr(void)
|
||||
{
|
||||
rx_activity();
|
||||
exti_reset_request(EXTI0); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
|
||||
rx_activity(); // check which GPIO changed
|
||||
}
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0) && USART_SOFT_RX_PIN0==1) || (defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1) && USART_SOFT_RX_PIN1==1) || (defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2) && USART_SOFT_RX_PIN2==1) || (defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN3) && USART_SOFT_RX_PIN3==1)
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==1) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==1) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==1) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==1)
|
||||
void exti1_isr(void)
|
||||
{
|
||||
rx_activity();
|
||||
exti_reset_request(EXTI1); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
|
||||
rx_activity(); // check which GPIO changed
|
||||
}
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0) && USART_SOFT_RX_PIN0==2) || (defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1) && USART_SOFT_RX_PIN1==2) || (defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2) && USART_SOFT_RX_PIN2==2) || (defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN3) && USART_SOFT_RX_PIN3==2)
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==2) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==2) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==2) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==2)
|
||||
void exti2_isr(void)
|
||||
{
|
||||
rx_activity();
|
||||
exti_reset_request(EXTI2); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
|
||||
rx_activity(); // check which GPIO changed
|
||||
}
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0) && USART_SOFT_RX_PIN0==3) || (defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1) && USART_SOFT_RX_PIN1==3) || (defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2) && USART_SOFT_RX_PIN2==3) || (defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN3) && USART_SOFT_RX_PIN3==3)
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==3) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==3) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==3) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==3)
|
||||
void exti3_isr(void)
|
||||
{
|
||||
rx_activity();
|
||||
exti_reset_request(EXTI3); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
|
||||
rx_activity(); // check which GPIO changed
|
||||
}
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0) && USART_SOFT_RX_PIN0==4) || (defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1) && USART_SOFT_RX_PIN1==4) || (defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2) && USART_SOFT_RX_PIN2==4) || (defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN3) && USART_SOFT_RX_PIN3==4)
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==4) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==4) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==4) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==4)
|
||||
void exti4_isr(void)
|
||||
{
|
||||
rx_activity();
|
||||
exti_reset_request(EXTI4); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
|
||||
rx_activity(); // check which GPIO changed
|
||||
}
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0) && (USART_SOFT_RX_PIN0==5 || USART_SOFT_RX_PIN0==6 || USART_SOFT_RX_PIN0==7 || USART_SOFT_RX_PIN0==8 || USART_SOFT_RX_PIN0==9)) || (defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1) && (USART_SOFT_RX_PIN1==5 || USART_SOFT_RX_PIN1==6 || USART_SOFT_RX_PIN1==7 || USART_SOFT_RX_PIN1==8 || USART_SOFT_RX_PIN1==9)) || (defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2) && (USART_SOFT_RX_PIN2==5 || USART_SOFT_RX_PIN2==6 || USART_SOFT_RX_PIN2==7 || USART_SOFT_RX_PIN2==8 || USART_SOFT_RX_PIN2==9)) || (defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN3) && (USART_SOFT_RX_PIN3==5 || USART_SOFT_RX_PIN3==6 || USART_SOFT_RX_PIN3==7 || USART_SOFT_RX_PIN3==8 || USART_SOFT_RX_PIN3==9))
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && (UART_SOFT_RX_PIN0==5 || UART_SOFT_RX_PIN0==6 || UART_SOFT_RX_PIN0==7 || UART_SOFT_RX_PIN0==8 || UART_SOFT_RX_PIN0==9)) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && (UART_SOFT_RX_PIN1==5 || UART_SOFT_RX_PIN1==6 || UART_SOFT_RX_PIN1==7 || UART_SOFT_RX_PIN1==8 || UART_SOFT_RX_PIN1==9)) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && (UART_SOFT_RX_PIN2==5 || UART_SOFT_RX_PIN2==6 || UART_SOFT_RX_PIN2==7 || UART_SOFT_RX_PIN2==8 || UART_SOFT_RX_PIN2==9)) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && (UART_SOFT_RX_PIN3==5 || UART_SOFT_RX_PIN3==6 || UART_SOFT_RX_PIN3==7 || UART_SOFT_RX_PIN3==8 || UART_SOFT_RX_PIN3==9))
|
||||
void exti9_5_isr(void)
|
||||
{
|
||||
rx_activity();
|
||||
exti_reset_request(EXTI5|EXTI6|EXTI7|EXTI8|EXTI9); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
|
||||
rx_activity(); // check which GPIO changed
|
||||
}
|
||||
#endif
|
||||
#if (defined(USART_SOFT_RX_PORT0) && defined(USART_SOFT_RX_PIN0) && (USART_SOFT_RX_PIN0==10 || USART_SOFT_RX_PIN0==11 || USART_SOFT_RX_PIN0==12 || USART_SOFT_RX_PIN0==13 || USART_SOFT_RX_PIN0==14 || USART_SOFT_RX_PIN0==15)) || (defined(USART_SOFT_RX_PORT1) && defined(USART_SOFT_RX_PIN1) && (USART_SOFT_RX_PIN1==10 || USART_SOFT_RX_PIN1==11 || USART_SOFT_RX_PIN1==12 || USART_SOFT_RX_PIN1==13 || USART_SOFT_RX_PIN1==14 || USART_SOFT_RX_PIN1==15)) || (defined(USART_SOFT_RX_PORT2) && defined(USART_SOFT_RX_PIN2) && (USART_SOFT_RX_PIN2==10 || USART_SOFT_RX_PIN2==11 || USART_SOFT_RX_PIN2==12 || USART_SOFT_RX_PIN2==13 || USART_SOFT_RX_PIN2==14 || USART_SOFT_RX_PIN2==15)) || (defined(USART_SOFT_RX_PORT3) && defined(USART_SOFT_RX_PIN3) && (USART_SOFT_RX_PIN3==10 || USART_SOFT_RX_PIN3==11 || USART_SOFT_RX_PIN3==12 || USART_SOFT_RX_PIN3==13 || USART_SOFT_RX_PIN3==14 || USART_SOFT_RX_PIN3==15))
|
||||
#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && (UART_SOFT_RX_PIN0==10 || UART_SOFT_RX_PIN0==11 || UART_SOFT_RX_PIN0==12 || UART_SOFT_RX_PIN0==13 || UART_SOFT_RX_PIN0==14 || UART_SOFT_RX_PIN0==15)) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && (UART_SOFT_RX_PIN1==10 || UART_SOFT_RX_PIN1==11 || UART_SOFT_RX_PIN1==12 || UART_SOFT_RX_PIN1==13 || UART_SOFT_RX_PIN1==14 || UART_SOFT_RX_PIN1==15)) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && (UART_SOFT_RX_PIN2==10 || UART_SOFT_RX_PIN2==11 || UART_SOFT_RX_PIN2==12 || UART_SOFT_RX_PIN2==13 || UART_SOFT_RX_PIN2==14 || UART_SOFT_RX_PIN2==15)) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && (UART_SOFT_RX_PIN3==10 || UART_SOFT_RX_PIN3==11 || UART_SOFT_RX_PIN3==12 || UART_SOFT_RX_PIN3==13 || UART_SOFT_RX_PIN3==14 || UART_SOFT_RX_PIN3==15))
|
||||
void exti15_10_isr(void)
|
||||
{
|
||||
rx_activity();
|
||||
exti_reset_request(EXTI10|EXTI11|EXTI12|EXTI13|EXTI14|EXTI15); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
|
||||
rx_activity(); // check which GPIO changed
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -12,14 +12,14 @@
|
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
/** library to control multiple software USARTs (API)
|
||||
* @file usart_soft.h
|
||||
/** library to control multiple software UARTs (API)
|
||||
* @file uart_soft.h
|
||||
* @author King Kévin <kingkevin@cuvoodoo.info>
|
||||
* @date 2016
|
||||
* @note peripherals used: GPIO @ref usart_soft_gpio, timer @ref usart_soft_timer
|
||||
* @note peripherals used: GPIO @ref uart_soft_gpio, timer @ref uart_soft_timer
|
||||
*/
|
||||
|
||||
/** setup software USART ports
|
||||
/** setup software UART ports
|
||||
* @return is setup succeeded, else the configuration is wrong
|
||||
*/
|
||||
bool usart_soft_setup(void);
|
||||
bool uart_soft_setup(void);
|
||||
|
|
|
|||
11
main.c
11
main.c
|
|
@ -130,6 +130,7 @@ static void process_command(char* str)
|
|||
return; // command successfully processed
|
||||
error:
|
||||
printf("command not recognized. enter help to list commands\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/** program entry point
|
||||
|
|
@ -152,6 +153,14 @@ void main(void)
|
|||
// minimal setup ready
|
||||
printf("welcome to the STM32F1 CuVoodoo example code\n"); // print welcome message
|
||||
|
||||
// setup software UART
|
||||
printf("setup software UART: ");
|
||||
if (uart_soft_setup()) {
|
||||
printf("OK\n");
|
||||
} else {
|
||||
printf("KO\n");
|
||||
}
|
||||
|
||||
// setup RTC
|
||||
printf("setup internal RTC: ");
|
||||
rtc_auto_awake(RCC_LSE, 32768-1); // ensure internal RTC is on, uses the 32.678 kHz LSE, and the prescale is set to our tick speed, else update backup registers accordingly (power off the micro-controller for the change to take effect)
|
||||
|
|
@ -234,5 +243,5 @@ void rtc_isr(void)
|
|||
{
|
||||
rtc_clear_flag(RTC_SEC); // clear flag
|
||||
rtc_internal_tick_flag = true; // notify to show new time
|
||||
led_toggle(); // blink every second to show the firmware is running
|
||||
//led_toggle(); // blink every second to show the firmware is running
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue