Add files via upload

6 files changed, 1062 insertions, 0 deletions

diff --git a/examples/usbtmc/src/main.c b/examples/usbtmc/src/main.c
new file mode 100644
index 0000000..6945d87
--- /dev/null
+++ b/examples/usbtmc/src/main.c
@@ -0,0 +1,144 @@
+/* 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "bsp/board.h"
+#include "tusb.h"
+#include "usbtmc_app.h"
+//--------------------------------------------------------------------+
+// MACRO CONSTANT TYPEDEF PROTYPES
+//--------------------------------------------------------------------+
+
+/* Blink pattern
+ * - 250 ms  : device not mounted
+ * - 0 ms : device mounted
+ * - 2500 ms : device is suspended
+ */
+enum  {
+  BLINK_NOT_MOUNTED = 250,
+  BLINK_MOUNTED = 0,
+  BLINK_SUSPENDED = 2500,
+};
+
+static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
+
+void led_blinking_task(void);
+
+/*------------- MAIN -------------*/
+int main(void)
+{
+  board_init();
+
+  // init device stack on configured roothub port
+  tud_init(BOARD_TUD_RHPORT);
+
+  while (1)
+  {
+    tud_task(); // tinyusb device task
+    led_blinking_task();
+    usbtmc_app_task_iter();
+  }
+
+  return 0;
+}
+
+//--------------------------------------------------------------------+
+// Device callbacks
+//--------------------------------------------------------------------+
+
+// Invoked when device is mounted
+void tud_mount_cb(void)
+{
+  blink_interval_ms = BLINK_MOUNTED;
+}
+
+// Invoked when device is unmounted
+void tud_umount_cb(void)
+{
+  blink_interval_ms = BLINK_NOT_MOUNTED;
+}
+
+// Invoked when usb bus is suspended
+// remote_wakeup_en : if host allow us  to perform remote wakeup
+// Within 7ms, device must draw an average of current less than 2.5 mA from bus
+void tud_suspend_cb(bool remote_wakeup_en)
+{
+  (void) remote_wakeup_en;
+  blink_interval_ms = BLINK_SUSPENDED;
+}
+
+// Invoked when usb bus is resumed
+void tud_resume_cb(void)
+{
+  blink_interval_ms = BLINK_MOUNTED;
+}
+
+//--------------------------------------------------------------------+
+// BLINKING TASK + Indicator pulse
+//--------------------------------------------------------------------+
+
+
+volatile uint8_t doPulse = false;
+// called from USB context
+void led_indicator_pulse(void) {
+	doPulse = true;
+}
+
+void led_blinking_task(void)
+{
+  static uint32_t start_ms = 0;
+  static bool led_state = false;
+  if(blink_interval_ms == BLINK_MOUNTED) // Mounted
+  {
+    if(doPulse)
+    {
+      led_state = true;
+      board_led_write(true);
+      start_ms = board_millis();
+      doPulse = false;
+    }
+    else if (led_state == true)
+    {
+      if ( board_millis() - start_ms < 750) //Spec says blink must be between 500 and 1000 ms.
+      {
+        return; // not enough time
+      }
+      led_state = false;
+      board_led_write(false);
+    }
+  }
+  else
+  {
+    // Blink every interval ms
+    if ( board_millis() - start_ms < blink_interval_ms) return; // not enough time
+    start_ms += blink_interval_ms;
+
+    board_led_write(led_state);
+    led_state = 1 - led_state; // toggle
+  }
+}
diff --git a/examples/usbtmc/src/main.h b/examples/usbtmc/src/main.h
new file mode 100644
index 0000000..673247e
--- /dev/null
+++ b/examples/usbtmc/src/main.h
@@ -0,0 +1,5 @@
+#ifndef MAIN_H
+#define MAIN_H
+void led_indicator_pulse(void);
+
+#endif
diff --git a/examples/usbtmc/src/tusb_config.h b/examples/usbtmc/src/tusb_config.h
new file mode 100644
index 0000000..ab486b1
--- /dev/null
+++ b/examples/usbtmc/src/tusb_config.h
@@ -0,0 +1,85 @@
+/*
+ * tusb_config.h
+ *
+ *  Created on: Sep 5, 2019
+ *      Author: nconrad
+ */
+
+#ifndef TUSB_CONFIG_H_
+#define TUSB_CONFIG_H_
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+//--------------------------------------------------------------------+
+// Board Specific Configuration
+//--------------------------------------------------------------------+
+
+// RHPort number used for device can be defined by board.mk, default to port 0
+#ifndef BOARD_TUD_RHPORT
+#define BOARD_TUD_RHPORT      0
+#endif
+
+// RHPort max operational speed can defined by board.mk
+#ifndef BOARD_TUD_MAX_SPEED
+#define BOARD_TUD_MAX_SPEED   OPT_MODE_DEFAULT_SPEED
+#endif
+
+//--------------------------------------------------------------------
+// Common Configuration
+//--------------------------------------------------------------------
+
+// defined by compiler flags for flexibility
+#ifndef CFG_TUSB_MCU
+#error CFG_TUSB_MCU must be defined
+#endif
+
+#ifndef CFG_TUSB_OS
+#define CFG_TUSB_OS           OPT_OS_NONE
+#endif
+
+#ifndef CFG_TUSB_DEBUG
+#define CFG_TUSB_DEBUG        0
+#endif
+
+// Enable Device stack
+#define CFG_TUD_ENABLED       1
+
+// Default is max speed that hardware controller could support with on-chip PHY
+#define CFG_TUD_MAX_SPEED     BOARD_TUD_MAX_SPEED
+
+/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment.
+ * Tinyusb use follows macros to declare transferring memory so that they can be put
+ * into those specific section.
+ * e.g
+ * - CFG_TUSB_MEM SECTION : __attribute__ (( section(".usb_ram") ))
+ * - CFG_TUSB_MEM_ALIGN   : __attribute__ ((aligned(4)))
+ */
+#ifndef CFG_TUSB_MEM_SECTION
+#define CFG_TUSB_MEM_SECTION
+#endif
+
+#ifndef CFG_TUSB_MEM_ALIGN
+#define CFG_TUSB_MEM_ALIGN        __attribute__ ((aligned(4)))
+#endif
+
+//--------------------------------------------------------------------
+// DEVICE CONFIGURATION
+//--------------------------------------------------------------------
+
+#ifndef CFG_TUD_ENDPOINT0_SIZE
+#define CFG_TUD_ENDPOINT0_SIZE    64
+#endif
+
+//------------- CLASS -------------//
+
+#define CFG_TUD_USBTMC                1
+#define CFG_TUD_USBTMC_ENABLE_INT_EP  1
+#define CFG_TUD_USBTMC_ENABLE_488     1
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* TUSB_CONFIG_H_ */
diff --git a/examples/usbtmc/src/usb_descriptors.c b/examples/usbtmc/src/usb_descriptors.c
new file mode 100644
index 0000000..5272f03
--- /dev/null
+++ b/examples/usbtmc/src/usb_descriptors.c
@@ -0,0 +1,242 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "tusb.h"
+#include "class/usbtmc/usbtmc.h"
+#include "class/usbtmc/usbtmc_device.h"
+
+/* A combination of interfaces must have a unique product id, since PC will save device driver after the first plug.
+ * Same VID/PID with different interface e.g MSC (first), then CDC (later) will possibly cause system error on PC.
+ *
+ * Auto ProductID layout's Bitmap:
+ *   [MSB]         HID | MSC | CDC          [LSB]
+ */
+#define _PID_MAP(itf, n)  ( (CFG_TUD_##itf) << (n) )
+#define USB_PID           (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \
+                           _PID_MAP(MIDI, 3) | _PID_MAP(VENDOR, 4) )
+
+#define USB_VID   0xCafe
+#define USB_BCD   0x0200
+
+//--------------------------------------------------------------------+
+// Device Descriptors
+//--------------------------------------------------------------------+
+tusb_desc_device_t const desc_device =
+{
+    .bLength            = sizeof(tusb_desc_device_t),
+    .bDescriptorType    = TUSB_DESC_DEVICE,
+    .bcdUSB             = 0x0200,
+    .bDeviceClass       = 0x00,
+    .bDeviceSubClass    = 0x00,
+    .bDeviceProtocol    = 0x00,
+
+    .bMaxPacketSize0    = CFG_TUD_ENDPOINT0_SIZE,
+
+    .idVendor           = USB_VID,
+    .idProduct          = USB_PID,
+    .bcdDevice          = USB_BCD,
+
+    .iManufacturer      = 0x01,
+    .iProduct           = 0x02,
+    .iSerialNumber      = 0x03,
+
+    .bNumConfigurations = 0x01
+};
+
+// Invoked when received GET DEVICE DESCRIPTOR
+// Application return pointer to descriptor
+uint8_t const * tud_descriptor_device_cb(void)
+{
+  return (uint8_t const *) &desc_device;
+}
+
+//--------------------------------------------------------------------+
+// Configuration Descriptor
+//--------------------------------------------------------------------+
+
+#if defined(CFG_TUD_USBTMC)
+
+#  define TUD_USBTMC_DESC_MAIN(_itfnum,_bNumEndpoints, _bulkMaxPacketLength) \
+     TUD_USBTMC_IF_DESCRIPTOR(_itfnum, _bNumEndpoints,  /*_stridx = */ 4u, TUD_USBTMC_PROTOCOL_USB488), \
+     TUD_USBTMC_BULK_DESCRIPTORS(/* OUT = */0x01, /* IN = */ 0x81, /* packet size = */_bulkMaxPacketLength)
+
+#if CFG_TUD_USBTMC_ENABLE_INT_EP
+// USBTMC Interrupt xfer always has length of 2, but we use epMaxSize=8 for
+//  compatibility with mcus that only allow 8, 16, 32 or 64 for FS endpoints
+#  define TUD_USBTMC_DESC(_itfnum, _bulkMaxPacketLength) \
+     TUD_USBTMC_DESC_MAIN(_itfnum, /* _epCount = */ 3, _bulkMaxPacketLength), \
+     TUD_USBTMC_INT_DESCRIPTOR(/* INT ep # */ 0x82, /* epMaxSize = */ 8, /* bInterval = */16u )
+#  define TUD_USBTMC_DESC_LEN (TUD_USBTMC_IF_DESCRIPTOR_LEN + TUD_USBTMC_BULK_DESCRIPTORS_LEN + TUD_USBTMC_INT_DESCRIPTOR_LEN)
+
+#else
+
+#  define TUD_USBTMC_DESC(_itfnum, _bulkMaxPacketLength) \
+     TUD_USBTMC_DESC_MAIN(_itfnum, /* _epCount = */ 2u, _bulkMaxPacketLength)
+#  define TUD_USBTMC_DESC_LEN (TUD_USBTMC_IF_DESCRIPTOR_LEN + TUD_USBTMC_BULK_DESCRIPTORS_LEN)
+
+#endif /* CFG_TUD_USBTMC_ENABLE_INT_EP */
+
+#else
+#  define USBTMC_DESC_LEN (0)
+#endif /* CFG_TUD_USBTMC */
+
+enum
+{
+  ITF_NUM_USBTMC,
+  ITF_NUM_TOTAL
+};
+
+
+#define CONFIG_TOTAL_LEN    (TUD_CONFIG_DESC_LEN + TUD_USBTMC_DESC_LEN)
+
+#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X || CFG_TUSB_MCU == OPT_MCU_LPC177X_8X || CFG_TUSB_MCU == OPT_MCU_LPC40XX
+  // LPC 17xx and 40xx endpoint type (bulk/interrupt/iso) are fixed by its number
+  // 0 control, 1 In, 2 Bulk, 3 Iso, 4 In etc ...
+  // Note: since CDC EP ( 1 & 2), HID (4) are spot-on, thus we only need to force
+  // endpoint number for MSC to 5
+  #define EPNUM_MSC   0x05
+#else
+  #define EPNUM_MSC   0x03
+#endif
+
+
+uint8_t const desc_fs_configuration[] =
+{
+  // Config number, interface count, string index, total length, attribute, power in mA
+  TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, 0x00, 100),
+
+  TUD_USBTMC_DESC(ITF_NUM_USBTMC, /* _bulkMaxPacketLength = */ 64),
+};
+
+#if TUD_OPT_HIGH_SPEED
+
+uint8_t const desc_hs_configuration[] =
+{
+  // Config number, interface count, string index, total length, attribute, power in mA
+  TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, 0x00, 100),
+
+  TUD_USBTMC_DESC(ITF_NUM_USBTMC, /* _bulkMaxPacketLength = */ 512),
+};
+
+// other speed configuration
+uint8_t desc_other_speed_config[CONFIG_TOTAL_LEN];
+
+// device qualifier is mostly similar to device descriptor since we don't change configuration based on speed
+tusb_desc_device_qualifier_t const desc_device_qualifier =
+{
+  .bLength            = sizeof(tusb_desc_device_qualifier_t),
+  .bDescriptorType    = TUSB_DESC_DEVICE_QUALIFIER,
+  .bcdUSB             = USB_BCD,
+
+  .bDeviceClass       = 0x00,
+  .bDeviceSubClass    = 0x00,
+  .bDeviceProtocol    = 0x00,
+
+  .bMaxPacketSize0    = CFG_TUD_ENDPOINT0_SIZE,
+  .bNumConfigurations = 0x01,
+  .bReserved          = 0x00
+};
+
+// Invoked when received GET DEVICE QUALIFIER DESCRIPTOR request
+// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete.
+// device_qualifier descriptor describes information about a high-speed capable device that would
+// change if the device were operating at the other speed. If not highspeed capable stall this request.
+uint8_t const* tud_descriptor_device_qualifier_cb(void)
+{
+  return (uint8_t const*) &desc_device_qualifier;
+}
+
+#endif
+
+// Invoked when received GET CONFIGURATION DESCRIPTOR
+// Application return pointer to descriptor
+// Descriptor contents must exist long enough for transfer to complete
+uint8_t const * tud_descriptor_configuration_cb(uint8_t index)
+{
+  (void) index; // for multiple configurations
+#if TUD_OPT_HIGH_SPEED
+  // Although we are highspeed, host may be fullspeed.
+  return (tud_speed_get() == TUSB_SPEED_HIGH) ?  desc_hs_configuration : desc_fs_configuration;
+#else
+  return desc_fs_configuration;
+#endif
+}
+
+//--------------------------------------------------------------------+
+// String Descriptors
+//--------------------------------------------------------------------+
+
+// array of pointer to string descriptors
+char const* string_desc_arr [] =
+{
+  (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409)
+  "EsPiFF-USBTMC",               // 1: Manufacturer
+  "EsPiFF HAT-Instrument",       // 2: Product
+  "123456",                      // 3: Serials, should use chip ID
+  "TinyUSB USBTMC",              // 4: USBTMC
+};
+
+static uint16_t _desc_str[32];
+
+// Invoked when received GET STRING DESCRIPTOR request
+// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete
+uint16_t const* tud_descriptor_string_cb(uint8_t index, uint16_t langid)
+{
+  (void) langid;
+
+  size_t chr_count;
+
+  if ( index == 0)
+  {
+    memcpy(&_desc_str[1], string_desc_arr[0], 2);
+    chr_count = 1;
+  }
+  else
+  {
+    // Note: the 0xEE index string is a Microsoft OS 1.0 Descriptors.
+    // https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/microsoft-defined-usb-descriptors
+
+    if ( !(index < sizeof(string_desc_arr)/sizeof(string_desc_arr[0])) ) return NULL;
+
+    const char* str = string_desc_arr[index];
+
+    // Cap at max char
+    chr_count = (uint8_t) strlen(str);
+    if ( chr_count > 31 ) {
+      chr_count = 31;
+    }
+
+    // Convert ASCII string into UTF-16
+    for(uint8_t i=0; i<chr_count; i++)
+    {
+      _desc_str[1+i] = str[i];
+    }
+  }
+
+  // first byte is length (including header), second byte is string type
+  _desc_str[0] = (uint16_t)((((uint16_t)TUSB_DESC_STRING) << 8 ) | (2u*chr_count + 2u));
+
+  return _desc_str;
+}
diff --git a/examples/usbtmc/src/usbtmc_app.c b/examples/usbtmc/src/usbtmc_app.c
new file mode 100644
index 0000000..dd8e2e5
--- /dev/null
+++ b/examples/usbtmc/src/usbtmc_app.c
@@ -0,0 +1,579 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 MDC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#define IDN             "EsPiFF-USBTMC"
+#define IDN_QUERY       "*idn?"
+#define RST_CMD         "*rst"
+#define DAC1_CMD         "sourc1:volt:lev " // SOURCe1:VOLTage:LEVel
+#define DAC1_QUERY       "sourc1:volt:lev?" // SOURCe1:VOLTage:LEVel
+
+//todo: add sourc2/3/4/.....
+
+#define ADC1_QUERY       "sens1:volt?"      // SENSe1:VOLTage
+
+//todo: add sens2/3/4/.....
+
+#define GPIO_LEV_CMD    "gpio1:lev "       // GPIO1:LEVel
+#define GPIO_LEV_QUERY  "gpio1:lev?"       // GPIO1:LEVel
+#define GPIO_DIR_CMD    "gpio1:dir "       // GPIO1:DIRection
+#define GPIO_DIR_QUERY  "gpio1:dir?"       // GPIO1:DIRection
+
+//todo: add gpio2/3/4/.....
+
+#define END_RESPONSE    "\n"               // USB488
+
+#include <strings.h>
+#include <stdlib.h>     /* atoi */
+#include <stdio.h>      /* fprintf */
+#include "tusb.h"
+#include "bsp/board.h"
+#include "main.h"
+#include "pico/stdlib.h"
+#include "pico/stdlib.h"
+#include "pico/binary_info.h"
+#include "hardware/spi.h"
+
+char * get_value(char *in_string);
+uint32_t adc_get_sample(void);
+void ftoa(float num, char *str);
+
+#if (CFG_TUD_USBTMC_ENABLE_488)
+static usbtmc_response_capabilities_488_t const
+#else
+static usbtmc_response_capabilities_t const
+#endif
+tud_usbtmc_app_capabilities  =
+{
+    .USBTMC_status = USBTMC_STATUS_SUCCESS,
+    .bcdUSBTMC = USBTMC_VERSION,
+    .bmIntfcCapabilities =
+    {
+        .listenOnly = 0,
+        .talkOnly = 0,
+        .supportsIndicatorPulse = 1
+		// there is currently no direct LED addressable on the EsPiFF. Ether ask the ESP32 to light up a LED, or the HAT must provide an LED
+    },
+    .bmDevCapabilities = {
+        .canEndBulkInOnTermChar = 0
+    },
+
+#if (CFG_TUD_USBTMC_ENABLE_488)
+    .bcdUSB488 = USBTMC_488_VERSION,
+    .bmIntfcCapabilities488 =
+    {
+        .supportsTrigger = 1,
+        .supportsREN_GTL_LLO = 0,
+        .is488_2 = 1
+    },
+    .bmDevCapabilities488 =
+    {
+      .SCPI = 1,
+      .SR1 = 0,
+      .RL1 = 0,
+      .DT1 =0,
+    }
+#endif
+};
+
+#define IEEE4882_STB_QUESTIONABLE (0x08u)
+#define IEEE4882_STB_MAV          (0x10u)
+#define IEEE4882_STB_SER          (0x20u)
+#define IEEE4882_STB_SRQ          (0x40u)
+
+//static const char idn[] = "TinyUSB,Seeeduino Xiao,v1\r\n";
+static volatile uint8_t status;
+
+// 0=not query, 1=queried, 2=delay,set(MAV), 3=delay 4=ready?
+// (to simulate delay)
+static volatile uint16_t queryState = 0;
+static volatile uint32_t queryDelayStart;
+static volatile uint32_t bulkInStarted;
+
+static volatile bool idnQuery;
+static volatile bool rst_cmd;
+static volatile bool dac_cmd1, dac_cmd2, dac_cmd3, dac_cmd4;
+static volatile bool dac_query1, dac_query2, dac_query3, dac_query4;
+static volatile bool adc_query1, adc_query2, adc_query3, adc_query4;
+static volatile bool gpio_lev_cmd;
+static volatile bool gpio_lev_query;
+static volatile bool gpio_dir_cmd;
+static volatile bool gpio_dir_query;
+
+static uint32_t resp_delay = 125u; // Adjustable delay, to allow for better testing
+static size_t   buffer_len;
+static size_t   buffer_tx_ix;      // for transmitting using multiple transfers
+static uint8_t  buffer[225];       // A few packets long should be enough.
+
+char adc_voltage_str[10];
+char dac_voltage_str[10];
+char gpio_lev_str[2];
+char gpio_dir_str[5];
+
+// HAT specific implementation:
+void gpio_setup(uint8_t ch);
+void dac_setup(uint8_t ch);
+void adc_setup(uint8_t ch);
+uint32_t adc_get_sample(uint8_t ch);
+void set_gpio_as_input(uint8_t ch);
+void set_gpio_as_output(uint8_t ch);
+bool is_gpio_output(uint8_t ch);
+uint32_t get_DAC_value(uint8_t ch);
+void dac_set_value(uint8_t ch, uint32_t new_val);
+
+
+static usbtmc_msg_dev_dep_msg_in_header_t rspMsg = {
+    .bmTransferAttributes =
+    {
+      .EOM = 1,
+      .UsingTermChar = 0
+    }
+};
+
+void tud_usbtmc_open_cb(uint8_t interface_id)
+{
+  (void)interface_id;
+  tud_usbtmc_start_bus_read();
+}
+
+#if (CFG_TUD_USBTMC_ENABLE_488)
+usbtmc_response_capabilities_488_t const *
+#else
+usbtmc_response_capabilities_t const *
+#endif
+tud_usbtmc_get_capabilities_cb()
+{
+  return &tud_usbtmc_app_capabilities;
+}
+
+
+bool tud_usbtmc_msg_trigger_cb(usbtmc_msg_generic_t* msg) {
+  (void)msg;
+  // Let trigger set the SRQ
+  status |= IEEE4882_STB_SRQ;
+  return true;
+}
+
+bool tud_usbtmc_msgBulkOut_start_cb(usbtmc_msg_request_dev_dep_out const * msgHeader)
+{
+  (void)msgHeader;
+  buffer_len = 0;
+  if(msgHeader->TransferSize > sizeof(buffer))
+  {
+
+    return false;
+  }
+  return true;
+}
+
+bool tud_usbtmc_msg_data_cb(void *data, size_t len, bool transfer_complete)
+{
+  // If transfer isn't finished, we just ignore it (for now)
+
+  if(len + buffer_len < sizeof(buffer))
+  {
+    memcpy(&(buffer[buffer_len]), data, len);
+    buffer_len += len;
+  }
+  else
+  {
+    return false; // buffer overflow!
+  }
+
+  queryState     = transfer_complete;
+  idnQuery       = false;
+  rst_cmd        = false;
+  dac_cmd1        = false;
+  dac_cmd2        = false;
+  dac_cmd3        = false;
+  dac_cmd4        = false;
+
+  dac_query1      = false;
+  dac_query2      = false;
+  dac_query3      = false;
+  dac_query4      = false;
+
+  adc_query1      = false;
+  adc_query2      = false;
+  adc_query3      = false;
+  adc_query4      = false;
+
+
+  gpio_lev_cmd   = false;
+  gpio_lev_query = false;
+  gpio_dir_cmd   = false;
+  gpio_dir_query = false;
+
+  if(transfer_complete && (len >=4) && !strncasecmp(IDN_QUERY,data,5))
+  {
+    idnQuery = true;
+  }
+  else if (transfer_complete && (len >=4) && !strncasecmp(RST_CMD,data,4))
+  {
+    rst_cmd = true;
+    clear_DAC_value();
+  }
+  else if (transfer_complete && (len >=16) && !strncasecmp(DAC1_CMD,data,16))
+  {
+    dac_cmd1            = true;
+    char *ptr_value    = get_value(data);
+    float dac_voltage  = strtof(ptr_value,NULL);
+    uint16_t dac_value = (int)( (dac_voltage / DAC_REF_VOLTAGE) * DAC_MAX_VALUE );
+    dac_set_value(1, dac_value);
+  }
+  else if (transfer_complete && (len >= 16) && !strncasecmp(DAC1_QUERY,data,16))
+  {
+    dac_query1 = true;
+    float dac_voltage = (float)get_DAC_value();
+    ftoa(dac_voltage,dac_voltage_str);
+//    strcat(dac_voltage_str,"\n");
+  }
+  else if (transfer_complete && (len >= 11) && !strncasecmp(ADC1_QUERY,data,11))
+  {
+    adc_query1         = true;
+    float adc_voltage =(float)(adc_get_sample()) / ADC_MAX_VALUE * ADC_REF_VOLTAGE;
+    ftoa(adc_voltage,adc_voltage_str);
+  }
+  else if (transfer_complete && (len >= 10) && !strncasecmp(GPIO_LEV_CMD,data,10))
+  {
+    gpio_lev_cmd = true;
+    char *ptr_value = get_value(data);
+    int gpio_level = atoi(ptr_value);
+    if (gpio_level == 1)
+    {
+      set_gpio_high(1, true);
+    }
+    else if (gpio_level == 0)
+    {
+    	set_gpio_high(1, false); // drive low value
+    }
+  }
+  else if (transfer_complete && (len >= 10) && !strncasecmp(GPIO_LEV_QUERY,data,10))
+  {
+    gpio_lev_query = true;
+    if ( is_gpio_high(1) )
+    {
+      strcpy(gpio_lev_str,"1");
+    }
+    else
+    {
+      strcpy(gpio_lev_str,"0");
+    }
+  }
+  else if (transfer_complete && (len >= 10) && !strncasecmp(GPIO_DIR_CMD,data,10))
+  {
+    gpio_dir_cmd    = true;
+    char *ptr_value = get_value(data);
+    if (!strncasecmp("IN",ptr_value,2))
+    {
+    	set_gpio_as_input(1); // PA10 as input
+    }
+    else if (!strncasecmp("OUT",ptr_value,3))
+    {
+    	set_gpio_as_output(1); // PA10 as output
+    }
+  }
+  else if (transfer_complete && (len >= 10) && !strncasecmp(GPIO_DIR_QUERY,data,10))
+  {
+    gpio_dir_query = true;
+    if (is_gpio_output() )
+    {
+      strcpy(gpio_dir_str,"OUT");
+    }
+    else
+    {
+      strcpy(gpio_dir_str,"IN");
+    }
+  }
+
+  if(transfer_complete && !strncasecmp("delay ",data,5))
+  {
+    queryState = 0;
+    int d = atoi((char*)data + 5);
+    if(d > 10000)
+      d = 10000;
+    if(d<0)
+      d=0;
+    resp_delay = (uint32_t)d;
+  }
+  tud_usbtmc_start_bus_read();
+  return true;
+}
+
+bool tud_usbtmc_msgBulkIn_complete_cb()
+{
+  if((buffer_tx_ix == buffer_len) || idnQuery) // done
+  {
+    status &= (uint8_t)~(IEEE4882_STB_MAV); // clear MAV
+    queryState = 0;
+    bulkInStarted = 0;
+    buffer_tx_ix = 0;
+  }
+  tud_usbtmc_start_bus_read();
+
+  return true;
+}
+
+static unsigned int msgReqLen;
+
+bool tud_usbtmc_msgBulkIn_request_cb(usbtmc_msg_request_dev_dep_in const * request)
+{
+  rspMsg.header.MsgID = request->header.MsgID,
+  rspMsg.header.bTag = request->header.bTag,
+  rspMsg.header.bTagInverse = request->header.bTagInverse;
+  msgReqLen = request->TransferSize;
+
+#ifdef xDEBUG
+  uart_tx_str_sync("MSG_IN_DATA: Requested!\r\n");
+#endif
+  if(queryState == 0 || (buffer_tx_ix == 0))
+  {
+    TU_ASSERT(bulkInStarted == 0);
+    bulkInStarted = 1;
+
+    // > If a USBTMC interface receives a Bulk-IN request prior to receiving a USBTMC command message
+    //   that expects a response, the device must NAK the request (*not stall*)
+  }
+  else
+  {
+    size_t txlen = tu_min32(buffer_len-buffer_tx_ix,msgReqLen);
+    tud_usbtmc_transmit_dev_msg_data(&buffer[buffer_tx_ix], txlen,
+        (buffer_tx_ix+txlen) == buffer_len, false);
+    buffer_tx_ix += txlen;
+  }
+  // Always return true indicating not to stall the EP.
+  return true;
+}
+
+void usbtmc_app_task_iter(void) {
+  switch(queryState) {
+  case 0:
+    break;
+  case 1:
+    queryDelayStart = board_millis();
+    queryState = 2;
+    break;
+  case 2:
+    if( (board_millis() - queryDelayStart) > resp_delay) {
+      queryDelayStart = board_millis();
+      queryState=3;
+      status |= 0x10u; // MAV
+      status |= 0x40u; // SRQ
+    }
+    break;
+  case 3:
+    if( (board_millis() - queryDelayStart) > resp_delay) {
+      queryState = 4;
+    }
+    break;
+  case 4: // time to transmit;
+    if(bulkInStarted && (buffer_tx_ix == 0)) {
+      if(idnQuery)
+      {
+        tud_usbtmc_transmit_dev_msg_data(IDN, tu_min32(sizeof(IDN)-1,msgReqLen),true,false);
+        queryState    = 0;
+        bulkInStarted = 0;
+      }
+      else if (adc_query1)
+      {
+        tud_usbtmc_transmit_dev_msg_data(adc_voltage_str, tu_min32(sizeof(adc_voltage_str)-1,msgReqLen),true,false);
+        queryState    = 0;
+        bulkInStarted = 0;
+      }
+      else if (dac_query1)
+      {
+        tud_usbtmc_transmit_dev_msg_data(dac_voltage_str, tu_min32(sizeof(dac_voltage_str)-1,msgReqLen),true,false);
+        queryState    = 0;
+        bulkInStarted = 0;
+      }
+      else if (gpio_lev_query)
+      {
+        tud_usbtmc_transmit_dev_msg_data(gpio_lev_str, tu_min32(sizeof(gpio_lev_str)-1,msgReqLen),true,false);
+        queryState    = 0;
+        bulkInStarted = 0;
+      }
+      else if (gpio_dir_query)
+      {
+        tud_usbtmc_transmit_dev_msg_data(gpio_dir_str, tu_min32(sizeof(gpio_dir_str)-1,msgReqLen),true,false);
+        queryState    = 0;
+        bulkInStarted = 0;
+      }
+      else if (rst_cmd || dac_cmd1 || gpio_lev_cmd || gpio_dir_cmd)
+      { 
+        tud_usbtmc_transmit_dev_msg_data(END_RESPONSE, tu_min32(sizeof(END_RESPONSE)-1,msgReqLen),true,false);
+        queryState    = 0;
+        bulkInStarted = 0;
+      }
+      else
+      {
+        buffer_tx_ix = tu_min32(buffer_len,msgReqLen);
+        tud_usbtmc_transmit_dev_msg_data(buffer, buffer_tx_ix, buffer_tx_ix == buffer_len, false);
+      }
+
+      // MAV is cleared in the transfer complete callback.
+    }
+    break;
+  default:
+    TU_ASSERT(false,);
+    return;
+  }
+}
+
+bool tud_usbtmc_initiate_clear_cb(uint8_t *tmcResult)
+{
+  *tmcResult = USBTMC_STATUS_SUCCESS;
+  queryState = 0;
+  bulkInStarted = false;
+  status = 0;
+  return true;
+}
+
+bool tud_usbtmc_check_clear_cb(usbtmc_get_clear_status_rsp_t *rsp)
+{
+  queryState = 0;
+  bulkInStarted = false;
+  status = 0;
+  buffer_tx_ix = 0u;
+  buffer_len = 0u;
+  rsp->USBTMC_status = USBTMC_STATUS_SUCCESS;
+  rsp->bmClear.BulkInFifoBytes = 0u;
+  return true;
+}
+bool tud_usbtmc_initiate_abort_bulk_in_cb(uint8_t *tmcResult)
+{
+  bulkInStarted = 0;
+  *tmcResult = USBTMC_STATUS_SUCCESS;
+  return true;
+}
+bool tud_usbtmc_check_abort_bulk_in_cb(usbtmc_check_abort_bulk_rsp_t *rsp)
+{
+  (void)rsp;
+  tud_usbtmc_start_bus_read();
+  return true;
+}
+
+bool tud_usbtmc_initiate_abort_bulk_out_cb(uint8_t *tmcResult)
+{
+  *tmcResult = USBTMC_STATUS_SUCCESS;
+  return true;
+
+}
+bool tud_usbtmc_check_abort_bulk_out_cb(usbtmc_check_abort_bulk_rsp_t *rsp)
+{
+  (void)rsp;
+  tud_usbtmc_start_bus_read();
+  return true;
+}
+
+void tud_usbtmc_bulkIn_clearFeature_cb(void)
+{
+}
+void tud_usbtmc_bulkOut_clearFeature_cb(void)
+{
+  tud_usbtmc_start_bus_read();
+}
+
+// Return status byte, but put the transfer result status code in the rspResult argument.
+uint8_t tud_usbtmc_get_stb_cb(uint8_t *tmcResult)
+{
+  uint8_t old_status = status;
+  status = (uint8_t)(status & ~(IEEE4882_STB_SRQ)); // clear SRQ
+
+  *tmcResult = USBTMC_STATUS_SUCCESS;
+  // Increment status so that we see different results on each read...
+
+  return old_status;
+}
+
+bool tud_usbtmc_indicator_pulse_cb(tusb_control_request_t const * msg, uint8_t *tmcResult)
+{
+  (void)msg;
+  led_indicator_pulse();
+  *tmcResult = USBTMC_STATUS_SUCCESS;
+  return true;
+}
+
+//---------------------------- New Code ----------------------------//
+
+void adc_setup(void) {
+  // todo: HAT specific implementation
+}
+
+uint32_t adc_get_sample(void) {
+  // todo: HAT specific implementation. 
+  //return the ADC value as an uint32_t
+}
+
+void dac_setup(void) {
+  //todo: HAT specific
+}
+
+void gpio_setup(void) {
+  //todo: HAT specific
+}
+
+char * get_value(char *in_string) {
+  char *ptr = strrchr(in_string,' ') + 1;
+  return ptr;
+}
+
+// char *ptr_value = get_value(scpi_string);
+// float value     = strtof(ptr_value,NULL);
+// char *command   = get_command(scpi_string,ptr_value);
+
+char * get_command(char *in_string, char *ptr_value) {
+  uint32_t command_len = ptr_value - in_string - 1;
+  char *command = (char *) malloc(command_len +1);
+  memcpy(command, in_string, command_len);
+  command[command_len] = '\0';
+  return command;
+}
+
+void ftoa(float num, char *str)
+{
+  int intpart = num;
+  int intdecimal;
+  uint32_t i;
+  float decimal_part;
+  char decimal[20];
+
+  memset(str, 0x0, 20);
+  itoa(num, str, 10);
+
+  strcat(str, ".");
+
+  decimal_part = num - intpart;
+  intdecimal = decimal_part * 1000;
+
+  if(intdecimal < 0)
+  {
+    intdecimal = -intdecimal;
+  }
+  itoa(intdecimal, decimal, 10);
+  for(i =0;i < (3 - strlen(decimal));i++)
+  {
+    strcat(str, "0");
+  }
+  strcat(str, decimal);
+}
diff --git a/examples/usbtmc/src/usbtmc_app.h b/examples/usbtmc/src/usbtmc_app.h
new file mode 100644
index 0000000..4de30c2
--- /dev/null
+++ b/examples/usbtmc/src/usbtmc_app.h
@@ -0,0 +1,7 @@
+
+#ifndef USBTMC_APP_H
+#define USBTMC_APP_H
+
+void usbtmc_app_task_iter(void);
+
+#endif