spark_abacus/lib/uart_soft.c

302 lines
18 KiB
C
Raw Normal View History

/* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* 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.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
2016-09-04 18:33:12 +02:00
/** library to control up to 4 independent receive and transmit software UART ports (code)
2016-09-04 14:48:40 +02:00
* @file uart_soft.c
* @author King Kévin <kingkevin@cuvoodoo.info>
* @date 2016
2016-09-04 14:48:40 +02:00
* @note peripherals used: GPIO @ref uart_soft_gpio, timer @ref uart_soft_timer
*/
/* standard libraries */
#include <stdint.h> // standard integer types
#include <stdlib.h> // general utilities
/* STM32 (including CM3) libraries */
#include <libopencm3/stm32/rcc.h> // real-time control clock library
#include <libopencm3/stm32/gpio.h> // general purpose input output library
#include <libopencm3/stm32/timer.h> // timer library
#include <libopencm3/cm3/nvic.h> // interrupt handler
2016-09-04 14:48:40 +02:00
#include <libopencm3/stm32/exti.h> // external interrupt defines
2016-09-04 18:33:12 +02:00
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
2016-09-04 14:48:40 +02:00
#include "uart_soft.h" // software UART library API
#include "global.h" // common methods
2016-09-04 18:33:12 +02:00
/** @defgroup uart_soft_gpio GPIO used for the software 4 UART ports
* @note comment if unused
2016-09-04 14:48:40 +02:00
* @warning only one port must be used per line (pin number)
* @{
*/
2016-09-04 14:48:40 +02:00
#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
/** @} */
2016-09-04 18:33:12 +02:00
/** buffer size for receive and transmit buffers */
#define UART_SOFT_BUFFER 64
/** UART receive state definition */
struct soft_uart_rx_state {
uint32_t port; /**< UART receive port */
uint16_t pin; /**< UART receive pin */
uint32_t rcc; /**< UART receive port peripheral clock */
uint32_t exti; /**< UART receive external interrupt */
uint32_t irq; /**< UART receive interrupt request */
uint32_t baudrate; /**< UART receive baud rate */
volatile uint16_t state; /**< GPIO state for receive pin */
volatile uint8_t bit; /**< next UART frame bit to receive */
volatile uint8_t byte; /**< byte being received */
volatile uint8_t buffer[UART_SOFT_BUFFER]; /**< receive buffer */
volatile uint8_t buffer_i; /**< index of current data to be read out */
volatile uint8_t buffer_used; /**< how much data is available */
volatile bool lock; /**< put lock when changing buffer_i or buffer_used */
volatile uint8_t buffer_byte; /**< to temporary store byte while locked */
volatile bool buffer_byte_used; /**< signal a byte has been stored in temporary buffer */
};
static struct soft_uart_rx_state* uart_soft_rx_states[4] = {NULL}; /**< states of UART ports (up to 4) */
volatile bool uart_soft_received[4] = {false, false, false, false};
2016-09-04 18:33:12 +02:00
/** @defgroup uart_soft_timer timer used to sample UART signals
* @{
*/
2016-09-04 14:48:40 +02:00
#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
2016-09-04 14:48:40 +02:00
#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
/** @} */
2016-09-04 18:33:12 +02:00
bool uart_soft_setup(uint32_t *rx_baudrates, uint32_t *tx_baudrates)
{
2016-09-04 18:33:12 +02:00
(void)rx_baudrates; // ensure compile does no complain even if no receive port is used
(void)tx_baudrates; // ensure compile does no complain even if no transmit port is used
#if defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0)
// save UART receive definition
uart_soft_rx_states[0] = calloc(1,sizeof(struct soft_uart_rx_state)); // create state definition
uart_soft_rx_states[0]->port = GPIO(UART_SOFT_RX_PORT0); // save receive port
uart_soft_rx_states[0]->pin = GPIO(UART_SOFT_RX_PIN0); // save receive pin
uart_soft_rx_states[0]->rcc = RCC_GPIO(UART_SOFT_RX_PORT0); // save receive port peripheral clock
uart_soft_rx_states[0]->exti = EXTI(UART_SOFT_RX_PIN0); // save receive external interrupt
uart_soft_rx_states[0]->irq = NVIC_EXTI_IRQ(UART_SOFT_RX_PIN0); // save receive interrupt request
2016-09-04 18:33:12 +02:00
#endif
// setup UART receive GPIO
for (uint8_t rx=0; rx<4; rx++) {
if (!uart_soft_rx_states[rx]) { // verify is receive UART is defined
continue; // skip configuration if not defined
}
if (!rx_baudrates || rx_baudrates[rx]==0) { // verify if baudrate has been defined
return false;
}
uart_soft_rx_states[0]->baudrate = rx_baudrates[0]; // save baud rate
rcc_periph_clock_enable(uart_soft_rx_states[rx]->rcc); // enable clock for GPIO peripheral
gpio_set_mode(uart_soft_rx_states[rx]->port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, uart_soft_rx_states[rx]->pin); // setup GPIO pin UART receive
gpio_set(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin); // pull up to avoid noise when not connected
2016-09-04 14:48:40 +02:00
rcc_periph_clock_enable(RCC_AFIO); // enable alternate function clock for external interrupt
2016-09-04 18:33:12 +02:00
exti_select_source(uart_soft_rx_states[rx]->exti, uart_soft_rx_states[rx]->port); // mask external interrupt of this pin only for this port
exti_enable_request(uart_soft_rx_states[rx]->exti); // enable external interrupt
exti_set_trigger(uart_soft_rx_states[rx]->exti, EXTI_TRIGGER_BOTH); // trigger when button is pressed
nvic_enable_irq(uart_soft_rx_states[rx]->irq); // enable interrupt
uart_soft_rx_states[rx]->state = gpio_get(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin); // save state of GPIO
uart_soft_rx_states[rx]->bit = 0; // reset bits received
}
2016-09-04 14:48:40 +02:00
#if defined(UART_SOFT_TX_PORT0) && defined(UART_SOFT_TX_PIN0)
2016-09-04 18:33:12 +02:00
// save UART transmit definition
//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
// setup timer
2016-09-04 14:48:40 +02:00
#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
2016-09-04 14:48:40 +02:00
#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
}
2016-09-04 14:48:40 +02:00
#if defined(UART_SOFT_RX_TIMER)
void TIM_ISR(UART_SOFT_RX_TIMER)(void)
{
2016-09-04 18:33:12 +02:00
const uint32_t timer_flags[4] = {TIM_SR_CC1IF,TIM_SR_CC2IF,TIM_SR_CC3IF,TIM_SR_CC4IF}; /**< the interrupt flags for the compare units */
const uint32_t timer_interrupt[4] = {TIM_DIER_CC1IE,TIM_DIER_CC2IE,TIM_DIER_CC3IE,TIM_DIER_CC4IE}; /**< the interrupt enable for the compare units */
const enum tim_oc_id timer_oc[4] = {TIM_OC1,TIM_OC2,TIM_OC3,TIM_OC4}; /**< the output compares for the compare units */
for (uint8_t rx=0; rx<4; rx++) {
if (timer_interrupt_source(TIM(UART_SOFT_RX_TIMER),timer_flags[rx])) { // got a match on compare for receive pin
timer_clear_flag(TIM(UART_SOFT_RX_TIMER),timer_flags[rx]); // clear flag
if (!uart_soft_rx_states[rx]) { // verify if RX exists
continue; // skip if receive port is not defined it
}
uart_soft_rx_states[rx]->byte += ((gpio_get(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin)==0 ? 0 : 1)<<(uart_soft_rx_states[rx]->bit-1)); // save bit value
if (uart_soft_rx_states[rx]->bit<8) { // not the last bit received
timer_set_oc_value(TIM(UART_SOFT_RX_TIMER),timer_oc[rx],timer_get_counter(TIM(UART_SOFT_RX_TIMER))+rcc_ahb_frequency/uart_soft_rx_states[rx]->baudrate); // set timer to next bit
uart_soft_rx_states[rx]->bit++; // wait for next bit
} else { // last bit received
if (uart_soft_rx_states[rx]->lock) { // someone is already reading data
uart_soft_rx_states[rx]->buffer_byte = uart_soft_rx_states[rx]->byte; // save byte
uart_soft_rx_states[rx]->buffer_byte_used = true; // notify reader there is a temporary byte
} else { // buffer can be updated
if (uart_soft_rx_states[rx]->buffer_used>=LENGTH(uart_soft_rx_states[rx]->buffer)) { // buffer is full
uart_soft_rx_states[rx]->buffer_i = (uart_soft_rx_states[rx]->buffer_i+1)%LENGTH(uart_soft_rx_states[rx]->buffer); // drop oldest byte
uart_soft_rx_states[rx]->buffer_used--; // update buffer usage
}
uart_soft_rx_states[rx]->buffer[(uart_soft_rx_states[rx]->buffer_i+uart_soft_rx_states[rx]->buffer_used)%LENGTH(uart_soft_rx_states[rx]->buffer)] = uart_soft_rx_states[rx]->byte; // put byte in buffer
uart_soft_rx_states[rx]->buffer_used++; // update used buffer
uart_soft_received[rx] = true; // notify user data is available
}
timer_disable_irq(TIM(UART_SOFT_RX_TIMER),timer_interrupt[rx]); // stop_interrupting
uart_soft_rx_states[rx]->bit = 0; // next bit should be first bit of next byte
}
2016-09-04 14:48:40 +02:00
}
}
}
#endif
2016-09-04 18:33:12 +02:00
uint8_t uart_soft_getbyte(uint8_t uart)
{
if (uart>=4 || !uart_soft_rx_states[uart]) { // ensure receive UART port is defined
return 0; // return
}
while (!uart_soft_rx_states[uart]->buffer_used) { // idle until data is available
__WFI(); // sleep until interrupt
}
uart_soft_rx_states[uart]->lock = true; // set lock
uint8_t to_return = uart_soft_rx_states[uart]->buffer[uart_soft_rx_states[uart]->buffer_i]; // get the next available character
uart_soft_rx_states[uart]->buffer_i = (uart_soft_rx_states[uart]->buffer_i+1)%LENGTH(uart_soft_rx_states[uart]->buffer); // update used buffer
uart_soft_rx_states[uart]->buffer_used--; // update used buffer
uart_soft_rx_states[uart]->lock = false; // free lock
if (uart_soft_rx_states[uart]->buffer_byte_used) { // temporary byte has been stored
uart_soft_rx_states[uart]->buffer[(uart_soft_rx_states[uart]->buffer_i+uart_soft_rx_states[uart]->buffer_used)%LENGTH(uart_soft_rx_states[uart]->buffer)] = uart_soft_rx_states[uart]->buffer_byte; // put byte in buffer
uart_soft_rx_states[uart]->buffer_used++; // update used buffer
uart_soft_rx_states[uart]->buffer_byte_used = false; // buffer byte is now in buffer
}
uart_soft_received[uart] = (uart_soft_rx_states[uart]->buffer_used!=0); // notify user if data is available
uart_soft_rx_states[uart]->lock = false; // free lock
return to_return;
}
2016-09-04 14:48:40 +02:00
#if defined(UART_SOFT_TX_TIMER)
void TIM_ISR(UART_SOFT_TX_TIMER)(void)
{
}
#endif
/** central function handling receive signal activity */
static void rx_activity(void)
{
2016-09-04 18:33:12 +02:00
const uint32_t timer_flags[4] = {TIM_SR_CC1IF,TIM_SR_CC2IF,TIM_SR_CC3IF,TIM_SR_CC4IF}; /**< the interrupt flags for the compare units */
const uint32_t timer_interrupt[4] = {TIM_DIER_CC1IE,TIM_DIER_CC2IE,TIM_DIER_CC3IE,TIM_DIER_CC4IE}; /**< the interrupt enable for the compare units */
const enum tim_oc_id timer_oc[4] = {TIM_OC1,TIM_OC2,TIM_OC3,TIM_OC4}; /**< the output compares for the compare units */
for (uint8_t rx=0; rx<4; rx++) {
if (!uart_soft_rx_states[rx]) { // verify if receive port is not configured
continue; // skip if receive port is not defined it
}
if (uart_soft_rx_states[rx]->state!=gpio_get(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin)) { // only do something if state changed
uart_soft_rx_states[rx]->state = gpio_get(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin); // save new state
if (uart_soft_rx_states[rx]->bit==0) { // start bit edge detected
if (uart_soft_rx_states[rx]->state==0) { // start bit has to be low
timer_set_oc_value(TIM(UART_SOFT_RX_TIMER), timer_oc[rx], timer_get_counter(TIM(UART_SOFT_RX_TIMER))+(rcc_ahb_frequency/uart_soft_rx_states[rx]->baudrate)*1.5); // set timer to sample data bit 0 in 1.5 bits
timer_clear_flag(TIM(UART_SOFT_RX_TIMER), timer_flags[rx]); // clear flag before enabling interrupt
timer_enable_irq(TIM(UART_SOFT_RX_TIMER), timer_interrupt[rx]);// enable timer IRQ for RX0
uart_soft_rx_states[rx]->byte = 0; // reset byte value
uart_soft_rx_states[rx]->bit++; // wait for first bit
}
} else { // data bit detected
timer_set_oc_value(TIM(UART_SOFT_RX_TIMER), timer_oc[rx], timer_get_counter(TIM(UART_SOFT_RX_TIMER))+(rcc_ahb_frequency/uart_soft_rx_states[rx]->baudrate)/2); // resync timer to half a bit (good for drifting transmission, bad if the line is noisy)
2016-09-04 14:48:40 +02:00
}
}
}
}
2016-09-04 14:48:40 +02:00
#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)
{
2016-09-04 14:48:40 +02:00
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
2016-09-04 14:48:40 +02:00
#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)
{
2016-09-04 14:48:40 +02:00
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
2016-09-04 14:48:40 +02:00
#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)
{
2016-09-04 14:48:40 +02:00
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
2016-09-04 14:48:40 +02:00
#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)
{
2016-09-04 14:48:40 +02:00
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
2016-09-04 14:48:40 +02:00
#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)
{
2016-09-04 14:48:40 +02:00
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
2016-09-04 14:48:40 +02:00
#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)
{
2016-09-04 14:48:40 +02:00
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
2016-09-04 14:48:40 +02:00
#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)
{
2016-09-04 14:48:40 +02:00
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