Commiting to start over

src/main/drivers/serial_usb_vcp.c

@@ -33,14 +33,6 @@
 #include "usb_io.h"
 #elif defined(STM32H7A3xx)
 #include "vcp_hal/stm32h7a3/usbd_cdc_if.h"
-int usbIsConnected(void);
-int usbIsConfigured(void);
-uint32_t CDC_Receive_DATA(uint8_t* recvBuf, uint32_t len);
-uint32_t CDC_Send_DATA(const uint8_t *ptrBuffer, uint32_t sendLength);
-uint32_t CDC_Receive_DATA(uint8_t* recvBuf, uint32_t len);
-uint32_t CDC_Receive_BytesAvailable(void);
-uint32_t CDC_Send_FreeBytes(void);
-uint32_t CDC_BaudRate(void);
 
 #elif defined(STM32F7) || defined(STM32H7)
 #include "vcp_hal/usbd_cdc_interface.h"

src/main/drivers/serial_usb_vcp.h

@@ -32,18 +32,5 @@ serialPort_t *usbVcpOpen(void);
 struct serialPort_s;
 uint32_t usbVcpGetBaudRate(struct serialPort_s *instance);
 
-
-#ifdef STM32H7A3xx
-void NMI_Handler(void);
-void HardFault_Handler(void);
-void MemManage_Handler(void);
-void BusFault_Handler(void);
-void UsageFault_Handler(void);
-void SVC_Handler(void);
-void DebugMon_Handler(void);
-void PendSV_Handler(void);
-void SysTick_Handler(void);
-void OTG_HS_EP1_OUT_IRQHandler(void);
-void OTG_HS_EP1_IN_IRQHandler(void);
-void OTG_HS_IRQHandler(void);
-#endif
+uint8_t usbIsConnected(void);
+uint8_t usbIsConfigured(void);

src/main/drivers/serial_usb_vcp_stm32h7a3.c

@@ -40,6 +40,7 @@
 #include "usbd_cdc.h"
 
 #ifdef STM32H7A3xx
+#include "vcp_hal/stm32h7a3/inav_cdc.h"
 #include "vcp_hal/stm32h7a3/usbd_cdc_if.h"
 #include "vcp_hal/stm32h7a3/usbd_desc.h"
 #else
@@ -95,49 +96,178 @@ void usbVcpInitHardware(void)
     //delay(100); // Cold boot failures observed without this, even when USB cable is not connected
     */
 }
+#define USB_TIMEOUT  50
 
-// interface code
-uint32_t CDC_Receive_BytesAvailable(void) {
-    // TODO: implement / remove
-    return 0;
+static vcpPort_t vcpPort;
+
+static void usbVcpSetBaudRate(serialPort_t *instance, uint32_t baudRate)
+{
+    UNUSED(instance);
+    UNUSED(baudRate);
+
+    // TODO implement
+}
+
+static void usbVcpSetMode(serialPort_t *instance, portMode_t mode)
+{
+    UNUSED(instance);
+    UNUSED(mode);
+
+    // TODO implement
+}
+
+static void usbVcpSetOptions(serialPort_t *instance, portOptions_t options)
+{
+    UNUSED(instance);
+    UNUSED(options);
+
+    // TODO implement
+}
+
+static bool isUsbVcpTransmitBufferEmpty(const serialPort_t *instance)
+{
+    UNUSED(instance);
+    return true;
+}
+
+static uint32_t usbVcpAvailable(const serialPort_t *instance)
+{
+    UNUSED(instance);
+
+    return CDC_Receive_BytesAvailable();
+}
+
+static uint8_t usbVcpRead(serialPort_t *instance)
+{
+    UNUSED(instance);
+
+    uint8_t buf[1];
+
+    while (true) {
+        if (CDC_Receive_DATA(buf, 1))
+            return buf[0];
+    }
+}
+
+static bool usbVcpIsConnected(const serialPort_t *instance)
+{
+    (void)instance;
+    return usbIsConnected() && usbIsConfigured();
+}
+
+static void usbVcpWriteBuf(serialPort_t *instance, const void *data, int count)
+{
+    UNUSED(instance);
+
+    if (!usbVcpIsConnected(instance)) {
+        return;
+    }
+
+    uint32_t start = millis();
+    const uint8_t *p = data;
+    while (count > 0) {
+        uint32_t txed = CDC_Send_DATA(p, count);
+        count -= txed;
+        p += txed;
+
+        if (millis() - start > USB_TIMEOUT) {
+            break;
+        }
+    }
+}
+
+static bool usbVcpFlush(vcpPort_t *port)
+{
+    uint32_t count = port->txAt;
+    port->txAt = 0;
+
+    if (count == 0) {
+        return true;
+    }
+
+    if (!usbIsConnected() || !usbIsConfigured()) {
+        return false;
+    }
+
+    uint32_t start = millis();
+    uint8_t *p = port->txBuf;
+    while (count > 0) {
+        uint32_t txed = CDC_Send_DATA(p, count);
+        count -= txed;
+        p += txed;
+
+        if (millis() - start > USB_TIMEOUT) {
+            break;
+        }
+    }
+    return count == 0;
 }
 
-uint32_t CDC_Receive_DATA(uint8_t* recvBuf, uint32_t len)
+static void usbVcpWrite(serialPort_t *instance, uint8_t c)
 {
-    UNUSED(recvBuf);
-    UNUSED(len);
-    return 0;
+    vcpPort_t *port = container_of(instance, vcpPort_t, port);
+
+    port->txBuf[port->txAt++] = c;
+    if (!port->buffering || port->txAt >= ARRAYLEN(port->txBuf)) {
+        usbVcpFlush(port);
+    }
 }
 
-uint32_t CDC_Send_DATA(const uint8_t *ptrBuffer, uint32_t sendLength) {
-    UNUSED(ptrBuffer);
-    UNUSED(sendLength);
-    // TODO: check
-    //return CDC_Transmit_HS(&hUsbDeviceHS, ptrBuffer, sendLength);
-    return 0;
+static void usbVcpBeginWrite(serialPort_t *instance)
+{
+    vcpPort_t *port = container_of(instance, vcpPort_t, port);
+    port->buffering = true;
 }
 
-int usbIsConnected(void)
+static uint32_t usbTxBytesFree(const serialPort_t *instance)
 {
-    // TODO: verify
-    return (hUsbDeviceHS.dev_state == USBD_STATE_CONFIGURED);
+    UNUSED(instance);
+    return CDC_Send_FreeBytes();
 }
 
-int usbIsConfigured(void)
+static void usbVcpEndWrite(serialPort_t *instance)
 {
-    // TODO: verify
-    return (hUsbDeviceHS.dev_state == USBD_STATE_CONFIGURED);
+    vcpPort_t *port = container_of(instance, vcpPort_t, port);
+    port->buffering = false;
+    usbVcpFlush(port);
 }
 
 
-uint32_t CDC_Send_FreeBytes(void) {
-    // TODO: implement
-    return 0;
+
+uint32_t usbVcpGetBaudRate(serialPort_t *instance)
+{
+    UNUSED(instance);
+
+    return CDC_BaudRate();
 }
 
-uint32_t CDC_BaudRate(void)
+static const struct serialPortVTable usbVTable[] = {
+    {
+        .serialWrite = usbVcpWrite,
+        .serialTotalRxWaiting = usbVcpAvailable,
+        .serialTotalTxFree = usbTxBytesFree,
+        .serialRead = usbVcpRead,
+        .serialSetBaudRate = usbVcpSetBaudRate,
+        .isSerialTransmitBufferEmpty = isUsbVcpTransmitBufferEmpty,
+        .setMode = usbVcpSetMode,
+        .setOptions = usbVcpSetOptions,
+        .isConnected = usbVcpIsConnected,
+        .writeBuf = usbVcpWriteBuf,
+        .beginWrite = usbVcpBeginWrite,
+        .endWrite = usbVcpEndWrite,
+        .isIdle = NULL,
+    }
+};
+
+serialPort_t *usbVcpOpen(void)
 {
-    return 115200;
+    vcpPort_t *s;
+
+    s = &vcpPort;
+    s->port.vTable = usbVTable;
+
+    return (serialPort_t *)s;
 }
 
+
 #endif

src/main/main.c

@@ -58,14 +58,122 @@ static void processLoopback(void)
 #endif
 }
 
+#ifdef STM32H7A3xx_NONONONONO
+ADC_HandleTypeDef hadc1;
+
+SPI_HandleTypeDef hspi1;
+SPI_HandleTypeDef hspi2;
+
+TIM_HandleTypeDef htim1;
+TIM_HandleTypeDef htim2;
+TIM_HandleTypeDef htim3;
+TIM_HandleTypeDef htim4;
+
+UART_HandleTypeDef huart4;
+UART_HandleTypeDef huart5;
+UART_HandleTypeDef huart1;
+UART_HandleTypeDef huart2;
+UART_HandleTypeDef huart3;
+UART_HandleTypeDef huart6;
+
+DMA_HandleTypeDef hdma_memtomem_bdma1_channel0;
+DMA_HandleTypeDef hdma_bdma_generator0;
+DMA_HandleTypeDef hdma_dma_generator0;
+DMA_HandleTypeDef hdma_dma_generator2;
+
+ void MX_GPIO_Init(void);
+ void MX_DMA_Init(void);
+ void MX_BDMA1_Init(void);
+ void MX_BDMA2_Init(void);
+ void MX_SPI1_Init(void);
+ void MX_SPI2_Init(void);
+ void MX_UART4_Init(void);
+ void MX_USART2_UART_Init(void);
+ void MX_USART3_UART_Init(void);
+ void MX_USART6_UART_Init(void);
+ void MX_USB_DEVICE_Init(void);
+ void MX_TIM1_Init(void);
+ void MX_TIM2_Init(void);
+ void MX_UART5_Init(void);
+ void MX_TIM4_Init(void);
+ void MX_TIM3_Init(void);
+ void MX_USART1_UART_Init(void);
+ void MX_ADC1_Init(void);
+#endif
+
 #if defined(SITL_BUILD)
 int main(int argc, char *argv[])
 {
     parseArguments(argc, argv);
 #else
-int main(void)
-{
+int main(void){
 #endif
+
+#ifdef STM32H7A3xx_NONONONONON
+  /* USER CODE BEGIN 1 */
+
+  /* USER CODE END 1 */
+
+  /* MPU Configuration--------------------------------------------------------*/
+  MPU_Config();
+
+  /* MCU Configuration--------------------------------------------------------*/
+
+  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
+  HAL_Init();
+
+  /* USER CODE BEGIN Init */
+
+  /* USER CODE END Init */
+
+  /* Configure the system clock */
+  SystemClock_Config();
+
+  /* Configure the peripherals common clocks */
+  PeriphCommonClock_Config();
+
+  /* USER CODE BEGIN SysInit */
+
+  /* USER CODE END SysInit */
+
+  /* Initialize all configured peripherals */
+  MX_GPIO_Init();
+  MX_DMA_Init();
+  MX_BDMA1_Init();
+  MX_BDMA2_Init();
+  MX_SPI1_Init();
+  MX_SPI2_Init();
+  MX_UART4_Init();
+  MX_USART2_UART_Init();
+  MX_USART3_UART_Init();
+  MX_USART6_UART_Init();
+  MX_USB_DEVICE_Init();
+  MX_TIM1_Init();
+  MX_TIM2_Init();
+  MX_UART5_Init();
+  MX_TIM4_Init();
+  MX_TIM3_Init();
+  MX_USART1_UART_Init();
+  MX_ADC1_Init();
+  /* USER CODE BEGIN 2 */
+
+  /* USER CODE END 2 */
+
+  /* Infinite loop */
+  /* USER CODE BEGIN WHILE */
+  while (1)
+  {
+	  HAL_GPIO_TogglePin (GPIOC, GPIO_PIN_13);
+	  HAL_Delay (1);   /* Insert delay 1 ms */
+	  // HAL_GPIO_TogglePin (GPIOC, GPIO_PIN_0);
+	  //CDC_Transmit_HS((uint8_t *)"Hello!\r\n", 8);
+
+    /* USER CODE END WHILE */
+
+    /* USER CODE BEGIN 3 */
+  }
+  /* USER CODE END 3 */
+#else
     init();
     loopbackInit();
 
@@ -76,4 +184,5 @@ int main(void)
         scheduler();
         processLoopback();
     }
+#endif
 }