mirror
/
AIOC
kopia lustrzana https://github.com/skuep/AIOC
1
0
Forkuj 0
Kod Zgłoszenia Packages Projekty Wydania Wiki Aktywność

Implemented functionality of hardware input pins on PB6/PB7

pull/89/head
Simon Kueppers 2024-09-17 13:56:37 +02:00
rodzic 0d58a07c2e
commit 6169b7911c
10 zmienionych plików z 256 dodań i 146 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

1
stm32/aioc-fw/Inc/aioc.h
Wyświetl plik

@ -2,6 +2,7 @@
#define AIOC_H_
#define AIOC_IRQ_PRIO_SYSTICK 6
#define AIOC_IRQ_PRIO_IO 5
#define AIOC_IRQ_PRIO_USB 4
#define AIOC_IRQ_PRIO_SERIAL 3
#define AIOC_IRQ_PRIO_AUDIO 2

3
stm32/aioc-fw/Src/cos.h
Wyświetl plik

@ -4,9 +4,10 @@
#include <stdint.h>
#include "stm32f3xx_hal.h"
#include "usb_hid.h"
#include "usb_serial.h"
#include "settings.h"
static inline void COS_SetState(uint8_t state)
static inline void COS_VirtualSetState(uint8_t state)
{
LED_SET(0, state & 0x01 ? 1 : 0);

82
stm32/aioc-fw/Src/io.c 100644
Wyświetl plik

@ -0,0 +1,82 @@
#include "io.h"
#include "usb_hid.h"
#include "usb_serial.h"
#include "settings.h"
void IO_IN_EXTI_ISR(void)
{
if (EXTI->PR & IO_IN_PIN_1_EXTI_PR) {
uint8_t state = IO_IN_GPIO->IDR & IO_IN_PIN_1 ? 0x00 : 0x01;
if (settingsRegMap[SETTINGS_REG_CM108_IOMUX0] & SETTINGS_REG_CM108_IOMUX0_BTN1SRC_IO1_MASK) {
USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_VOLUP : 0x00);
}
if (settingsRegMap[SETTINGS_REG_CM108_IOMUX1] & SETTINGS_REG_CM108_IOMUX1_BTN2SRC_IO1_MASK) {
USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_VOLDN : 0x00);
}
if (settingsRegMap[SETTINGS_REG_CM108_IOMUX2] & SETTINGS_REG_CM108_IOMUX2_BTN3SRC_IO1_MASK) {
USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_PLAYMUTE : 0x00);
}
if (settingsRegMap[SETTINGS_REG_CM108_IOMUX3] & SETTINGS_REG_CM108_IOMUX3_BTN4SRC_IO1_MASK) {
USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_RECMUTE : 0x00);
}
if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX0] & SETTINGS_REG_SERIAL_IOMUX0_DCDSRC_IO1_MASK) {
USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_DCD : 0x00);
}
if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX1] & SETTINGS_REG_SERIAL_IOMUX1_DSRSRC_IO1_MASK) {
USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_DSR : 0x00);
}
if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX2] & SETTINGS_REG_SERIAL_IOMUX2_RISRC_IO1_MASK) {
USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_RI : 0x00);
}
if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX3] & SETTINGS_REG_SERIAL_IOMUX3_BRKSRC_IO1_MASK) {
USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_BREAK : 0x00);
}
}
if (EXTI->PR & IO_IN_PIN_2_EXTI_PR) {
uint8_t state = IO_IN_GPIO->IDR & IO_IN_PIN_2 ? 0x00 : 0x01;
if (settingsRegMap[SETTINGS_REG_CM108_IOMUX0] & SETTINGS_REG_CM108_IOMUX0_BTN1SRC_IO2_MASK) {
USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_VOLUP : 0x00);
}
if (settingsRegMap[SETTINGS_REG_CM108_IOMUX1] & SETTINGS_REG_CM108_IOMUX1_BTN2SRC_IO2_MASK) {
USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_VOLDN : 0x00);
}
if (settingsRegMap[SETTINGS_REG_CM108_IOMUX2] & SETTINGS_REG_CM108_IOMUX2_BTN3SRC_IO2_MASK) {
USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_PLAYMUTE : 0x00);
}
if (settingsRegMap[SETTINGS_REG_CM108_IOMUX3] & SETTINGS_REG_CM108_IOMUX3_BTN4SRC_IO2_MASK) {
USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_RECMUTE : 0x00);
}
if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX0] & SETTINGS_REG_SERIAL_IOMUX0_DCDSRC_IO2_MASK) {
USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_DCD : 0x00);
}
if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX1] & SETTINGS_REG_SERIAL_IOMUX1_DSRSRC_IO2_MASK) {
USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_DSR : 0x00);
}
if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX2] & SETTINGS_REG_SERIAL_IOMUX2_RISRC_IO2_MASK) {
USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_RI : 0x00);
}
if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX3] & SETTINGS_REG_SERIAL_IOMUX3_BRKSRC_IO2_MASK) {
USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_BREAK : 0x00);
}
}
/* Clear flags */
EXTI->PR = IO_IN_PIN_1_EXTI_PR | IO_IN_PIN_2_EXTI_PR;
}

132
stm32/aioc-fw/Src/io.h 100644
Wyświetl plik

@ -0,0 +1,132 @@
#ifndef IO_H_
#define IO_H_
#include <stdint.h>
#include "stm32f3xx_hal.h"
#include "aioc.h"
#include "led.h"
#include "settings.h"
#define IO_PTT_MASK_NONE 0x00
#define IO_PTT_MASK_PTT1 0x01
#define IO_PTT_MASK_PTT2 0x02
#define IO_OUT_GPIO GPIOA
#define IO_OUT_PIN_1 GPIO_PIN_1
#define IO_OUT_PIN_2 GPIO_PIN_0
#define IO_IN_GPIO GPIOB
#define IO_IN_PIN_1 GPIO_PIN_6
#define IO_IN_PIN_2 GPIO_PIN_7
#define IO_IN_EXTI_ISR EXTI9_5_IRQHandler
#define IO_IN_PIN_1_EXTI_PR EXTI_PR_PR6
#define IO_IN_PIN_2_EXTI_PR EXTI_PR_PR7
#define IO_IN_IRQN EXTI9_5_IRQn
static inline void IO_PTTAssert(uint8_t pttMask)
{
__disable_irq();
if (pttMask & IO_PTT_MASK_PTT1) {
IO_OUT_GPIO->BSRR = IO_OUT_PIN_1;
LED_SET(1, 1);
/* Update debug register */
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_PTT1STATE_MASK;
}
if (pttMask & IO_PTT_MASK_PTT2) {
IO_OUT_GPIO->BSRR = IO_OUT_PIN_2;
LED_SET(0, 1);
/* Update debug register */
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_PTT2STATE_MASK;
}
__enable_irq();
}
static inline void IO_PTTDeassert(uint8_t pttMask)
{
__disable_irq();
if (pttMask & IO_PTT_MASK_PTT1) {
IO_OUT_GPIO->BRR = IO_OUT_PIN_1;
LED_SET(1, 0);
/* Update debug register */
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_PTT1STATE_MASK;
}
if (pttMask & IO_PTT_MASK_PTT2) {
IO_OUT_GPIO->BRR = IO_OUT_PIN_2;
LED_SET(0, 0);
/* Update debug register */
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_PTT2STATE_MASK;
}
__enable_irq();
}
static inline void IO_PTTControl(uint8_t pttMask)
{
/* TODO: Using this function, both PTTs can only be asserted/deasserted simultaneously.
* Switch to using fully event(edge) driven PTT assertion/deassertion using functions below */
if (pttMask & IO_PTT_MASK_PTT1) {
IO_PTTAssert(IO_PTT_MASK_PTT1);
} else {
IO_PTTDeassert(IO_PTT_MASK_PTT1);
}
if (pttMask & IO_PTT_MASK_PTT2) {
IO_PTTAssert(IO_PTT_MASK_PTT2);
} else {
IO_PTTDeassert(IO_PTT_MASK_PTT2);
}
}
static inline uint8_t IO_PTTStatus(void)
{
uint32_t inputReg = IO_OUT_GPIO->IDR;
return (inputReg & IO_OUT_PIN_1 ? IO_PTT_MASK_PTT1 : 0) |
(inputReg & IO_OUT_PIN_2 ? IO_PTT_MASK_PTT2 : 0);
}
static inline void IO_Init(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
/* Set up output GPIOs */
GPIO_InitTypeDef outGPIO = {
.Pin = (IO_OUT_PIN_2 | IO_OUT_PIN_1),
.Mode = GPIO_MODE_OUTPUT_PP,
.Pull = GPIO_PULLDOWN,
.Speed = GPIO_SPEED_FREQ_LOW,
.Alternate = 0
};
HAL_GPIO_Init(IO_OUT_GPIO, &outGPIO);
__HAL_RCC_GPIOB_CLK_ENABLE();
/* Set up input GPIOs */
GPIO_InitTypeDef inGPIO = {
.Pin = (IO_IN_PIN_2 | IO_IN_PIN_1),
.Mode = GPIO_MODE_IT_RISING_FALLING,
.Pull = GPIO_PULLUP,
.Speed = GPIO_SPEED_FREQ_LOW,
.Alternate = 0
};
HAL_GPIO_Init(IO_IN_GPIO, &inGPIO);
/* Clear any external interrupt and enable */
EXTI->PR = IO_IN_PIN_1_EXTI_PR | IO_IN_PIN_2_EXTI_PR;
NVIC_SetPriority(IO_IN_IRQN, AIOC_IRQ_PRIO_IO);
NVIC_ClearPendingIRQ(IO_IN_IRQN);
NVIC_EnableIRQ(IO_IN_IRQN);
}
#endif /* IO_H_ */

4
stm32/aioc-fw/Src/main.c
Wyświetl plik

@ -2,9 +2,9 @@
#include "aioc.h"
#include "settings.h"
#include "led.h"
#include "ptt.h"
#include "usb.h"
#include <assert.h>
#include <io.h>
#include <stdio.h>
// from ST application note AN2606
@ -185,7 +185,7 @@ int main(void)
LED_MODE(0, LED_MODE_SLOWPULSE2X);
LED_MODE(1, LED_MODE_SLOWPULSE2X);
PTT_Init();
IO_Init();
USB_Init();

106
stm32/aioc-fw/Src/ptt.h
Wyświetl plik

@ -1,106 +0,0 @@
#ifndef PTT_H_
#define PTT_H_
#include <stdint.h>
#include "stm32f3xx_hal.h"
#include "aioc.h"
#include "led.h"
#include "settings.h"
#define PTT_MASK_NONE 0x00
#define PTT_MASK_PTT1 0x01
#define PTT_MASK_PTT2 0x02
#define PTT_GPIO GPIOA
#define PTT_PIN_PTT1 GPIO_PIN_1
#define PTT_PIN_PTT2 GPIO_PIN_0
static inline void PTT_Assert(uint8_t pttMask)
{
__disable_irq();
if (pttMask & PTT_MASK_PTT1) {
PTT_GPIO->BSRR = PTT_PIN_PTT1;
LED_SET(1, 1);
/* Update debug register */
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_PTT1STATE_MASK;
}
if (pttMask & PTT_MASK_PTT2) {
PTT_GPIO->BSRR = PTT_PIN_PTT2;
LED_SET(0, 1);
/* Update debug register */
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_PTT2STATE_MASK;
}
__enable_irq();
}
static inline void PTT_Deassert(uint8_t pttMask)
{
__disable_irq();
if (pttMask & PTT_MASK_PTT1) {
PTT_GPIO->BRR = PTT_PIN_PTT1;
LED_SET(1, 0);
/* Update debug register */
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_PTT1STATE_MASK;
}
if (pttMask & PTT_MASK_PTT2) {
PTT_GPIO->BRR = PTT_PIN_PTT2;
LED_SET(0, 0);
/* Update debug register */
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_PTT2STATE_MASK;
}
__enable_irq();
}
static inline void PTT_Control(uint8_t pttMask)
{
/* TODO: Using this function, both PTTs can only be asserted/deasserted simultaneously.
* Switch to using fully event(edge) driven PTT assertion/deassertion using functions below */
if (pttMask & PTT_MASK_PTT1) {
PTT_Assert(PTT_MASK_PTT1);
} else {
PTT_Deassert(PTT_MASK_PTT1);
}
if (pttMask & PTT_MASK_PTT2) {
PTT_Assert(PTT_MASK_PTT2);
} else {
PTT_Deassert(PTT_MASK_PTT2);
}
}
static inline uint8_t PTT_Status(void)
{
uint32_t inputReg = PTT_GPIO->IDR;
return (inputReg & PTT_PIN_PTT1 ? PTT_MASK_PTT1 : 0) |
(inputReg & PTT_PIN_PTT2 ? PTT_MASK_PTT2 : 0);
}
static inline void PTT_Init(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
/* Set up PTT GPIOs */
GPIO_InitTypeDef pttGPIO = {
.Pin = (PTT_PIN_PTT2 | PTT_PIN_PTT1),
.Mode = GPIO_MODE_OUTPUT_PP,
.Pull = GPIO_PULLDOWN,
.Speed = GPIO_SPEED_FREQ_LOW,
.Alternate = 0
};
HAL_GPIO_Init(PTT_GPIO, &pttGPIO);
}
#endif /* PTT_H_ */

2
stm32/aioc-fw/Src/settings.h
Wyświetl plik

@ -68,7 +68,7 @@ extern uint32_t settingsRegMap[SETTINGS_REGMAP_SIZE];
#define SETTINGS_REG_CM108_IOMUX0 0x44
#define SETTINGS_REG_CM108_IOMUX0_DEFAULT (SETTINGS_REG_CM108_IOMUX0_BTN1SRC_DFLT)
/* BTN1SRC: Volume-Up Button source */
#define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_DFLT (SETTINGS_REG_CM108_IOMUX0_BTN1SRC_NONE_MASK)
#define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_DFLT (SETTINGS_REG_CM108_IOMUX0_BTN1SRC_IO2_MASK)
#define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_OFFS 0
#define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_MASK 0xFFFFFFFFUL
#define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_NONE_MASK 0x00000000UL

22
stm32/aioc-fw/Src/usb_audio.c
Wyświetl plik

@ -1,9 +1,9 @@
#include <io.h>
#include "usb_audio.h"
#include "stm32f3xx_hal.h"
#include "aioc.h"
#include "tusb.h"
#include "usb.h"
#include "ptt.h"
#include "cos.h"
#include <math.h>
@ -775,11 +775,11 @@ void TIM16_IRQHandler(void)
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_VPTTSTATE_MASK;
/* Assert enabled PTTs */
uint8_t pttMask = PTT_MASK_NONE;
pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_VPTT_MASK ? PTT_MASK_PTT1 : 0;
pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_VPTT_MASK ? PTT_MASK_PTT2 : 0;
uint8_t pttMask = IO_PTT_MASK_NONE;
pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_VPTT_MASK ? IO_PTT_MASK_PTT1 : 0;
pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_VPTT_MASK ? IO_PTT_MASK_PTT2 : 0;
PTT_Assert(pttMask);
IO_PTTAssert(pttMask);
}
} else if (flags & TIM_SR_CC1IF) {
/* The idle timeout (without any action on the DAC) was reached. Disable timer and deassert PTT */
@ -789,11 +789,11 @@ void TIM16_IRQHandler(void)
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_VPTTSTATE_MASK;
/* Deassert enabled PTTs */
uint8_t pttMask = PTT_MASK_NONE;
pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_VPTT_MASK ? PTT_MASK_PTT1 : 0;
pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_VPTT_MASK ? PTT_MASK_PTT2 : 0;
uint8_t pttMask = IO_PTT_MASK_NONE;
pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_VPTT_MASK ? IO_PTT_MASK_PTT1 : 0;
pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_VPTT_MASK ? IO_PTT_MASK_PTT2 : 0;
PTT_Deassert(pttMask);
IO_PTTDeassert(pttMask);
}
TIM16->SR = ~flags;
@ -815,7 +815,7 @@ void TIM17_IRQHandler(void)
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_VCOSSTATE_MASK;
/* Set COS state */
COS_SetState(0x01);
COS_VirtualSetState(0x01);
}
} else if (flags & TIM_SR_CC1IF) {
/* The idle timeout (without any action on the ADC) was reached. Disable timer and notify host */
@ -825,7 +825,7 @@ void TIM17_IRQHandler(void)
settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_VCOSSTATE_MASK;
/* Set COS state */
COS_SetState(0x00);
COS_VirtualSetState(0x00);
}
TIM17->SR = ~flags;

22
stm32/aioc-fw/Src/usb_hid.c
Wyświetl plik

@ -1,6 +1,6 @@
#include <io.h>
#include "usb_hid.h"
#include "tusb.h"
#include "ptt.h"
#include "settings.h"
#include "usb_descriptors.h"
@ -28,41 +28,41 @@ static bool SendReport(void)
static void ControlPTT(uint8_t gpio)
{
uint8_t pttMask = PTT_MASK_NONE;
uint8_t pttMask = IO_PTT_MASK_NONE;
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_CM108GPIO1_MASK) {
pttMask |= gpio & 0x01 ? PTT_MASK_PTT1 : 0;
pttMask |= gpio & 0x01 ? IO_PTT_MASK_PTT1 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_CM108GPIO2_MASK) {
pttMask |= gpio & 0x02 ? PTT_MASK_PTT1 : 0;
pttMask |= gpio & 0x02 ? IO_PTT_MASK_PTT1 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_CM108GPIO3_MASK) {
pttMask |= gpio & 0x04 ? PTT_MASK_PTT1 : 0;
pttMask |= gpio & 0x04 ? IO_PTT_MASK_PTT1 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_CM108GPIO4_MASK) {
pttMask |= gpio & 0x08 ? PTT_MASK_PTT1 : 0;
pttMask |= gpio & 0x08 ? IO_PTT_MASK_PTT1 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_CM108GPIO1_MASK) {
pttMask |= gpio & 0x01 ? PTT_MASK_PTT2 : 0;
pttMask |= gpio & 0x01 ? IO_PTT_MASK_PTT2 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_CM108GPIO2_MASK) {
pttMask |= gpio & 0x02 ? PTT_MASK_PTT2 : 0;
pttMask |= gpio & 0x02 ? IO_PTT_MASK_PTT2 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_CM108GPIO3_MASK) {
pttMask |= gpio & 0x04 ? PTT_MASK_PTT2 : 0;
pttMask |= gpio & 0x04 ? IO_PTT_MASK_PTT2 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_CM108GPIO4_MASK) {
pttMask |= gpio & 0x08 ? PTT_MASK_PTT2 : 0;
pttMask |= gpio & 0x08 ? IO_PTT_MASK_PTT2 : 0;
}
PTT_Control(pttMask);
IO_PTTControl(pttMask);
}
// Invoked when received GET_REPORT control request

28
stm32/aioc-fw/Src/usb_serial.c
Wyświetl plik

@ -1,9 +1,9 @@
#include <io.h>
#include "usb_serial.h"
#include "stm32f3xx_hal.h"
#include "aioc.h"
#include "tusb.h"
#include "led.h"
#include "ptt.h"
#include "settings.h"
#include "usb_descriptors.h"
@ -47,7 +47,7 @@ void USB_SERIAL_UART_IRQ(void)
/* RX register is not empty, get character and put into USB send buffer */
if (tud_cdc_n_write_available(0) > 0) {
uint8_t c = USB_SERIAL_UART->RDR;
uint8_t pttStatus = PTT_Status();
uint8_t pttStatus = IO_PTTStatus();
uint8_t pttRxIgnoreMask = (settingsRegMap[SETTINGS_REG_SERIAL_CTRL] & SETTINGS_REG_SERIAL_CTRL_RXIGNPTT_MASK) >> SETTINGS_REG_SERIAL_CTRL_RXIGNPTT_OFFS;
if (!(pttStatus & pttRxIgnoreMask) ) {
@ -89,12 +89,12 @@ void tud_cdc_rx_cb(uint8_t itf)
{
TU_ASSERT(itf == 0, /**/);
uint8_t pttStatus = PTT_Status();
uint8_t pttStatus = IO_PTTStatus();
uint8_t pttTxForceMask = (settingsRegMap[SETTINGS_REG_SERIAL_CTRL] & SETTINGS_REG_SERIAL_CTRL_TXFRCPTT_MASK) >> SETTINGS_REG_SERIAL_CTRL_TXFRCPTT_OFFS;
if (pttStatus & pttTxForceMask) {
/* Make sure the selected PTTs are disabled, since they might share a signal with the UART lines */
PTT_Control(pttStatus & ~pttTxForceMask);
IO_PTTControl(pttStatus & ~pttTxForceMask);
}
/* This enables the transmitter and the TX-empty interrupt, which handles writing UART data */
@ -174,43 +174,43 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
{
TU_ASSERT(itf == 0, /**/);
uint8_t pttMask = PTT_MASK_NONE;
uint8_t pttMask = IO_PTT_MASK_NONE;
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_SERIALDTR_MASK) {
pttMask |= dtr ? PTT_MASK_PTT1 : 0;
pttMask |= dtr ? IO_PTT_MASK_PTT1 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_SERIALRTS_MASK) {
pttMask |= rts ? PTT_MASK_PTT1 : 0;
pttMask |= rts ? IO_PTT_MASK_PTT1 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_SERIALDTRNRTS_MASK) {
pttMask |= (dtr && !rts) ? PTT_MASK_PTT1 : 0;
pttMask |= (dtr && !rts) ? IO_PTT_MASK_PTT1 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_SERIALNDTRRTS_MASK) {
pttMask |= (!dtr && rts) ? PTT_MASK_PTT1 : 0;
pttMask |= (!dtr && rts) ? IO_PTT_MASK_PTT1 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_SERIALDTR_MASK) {
pttMask |= dtr ? PTT_MASK_PTT2 : 0;
pttMask |= dtr ? IO_PTT_MASK_PTT2 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_SERIALRTS_MASK) {
pttMask |= rts ? PTT_MASK_PTT2 : 0;
pttMask |= rts ? IO_PTT_MASK_PTT2 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_SERIALDTRNRTS_MASK) {
pttMask |= (dtr && !rts) ? PTT_MASK_PTT2 : 0;
pttMask |= (dtr && !rts) ? IO_PTT_MASK_PTT2 : 0;
}
if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_SERIALNDTRRTS_MASK) {
pttMask |= (!dtr && rts) ? PTT_MASK_PTT2 : 0;
pttMask |= (!dtr && rts) ? IO_PTT_MASK_PTT2 : 0;
}
if (! (USB_SERIAL_UART->CR1 & USART_CR1_TE) ) {
/* Enable PTT only when UART transmitter is not currently transmitting */
PTT_Control(pttMask);
IO_PTTControl(pttMask);
}
}