From 39a5c822a2a2e798e2e39ff8a98b7af84253026c Mon Sep 17 00:00:00 2001 From: Joey Castillo Date: Sat, 28 Aug 2021 12:50:18 -0400 Subject: add tinyusb --- tinyusb/examples/device/usbtmc/src/usbtmc_app.c | 329 ++++++++++++++++++++++++ 1 file changed, 329 insertions(+) create mode 100755 tinyusb/examples/device/usbtmc/src/usbtmc_app.c (limited to 'tinyusb/examples/device/usbtmc/src/usbtmc_app.c') diff --git a/tinyusb/examples/device/usbtmc/src/usbtmc_app.c b/tinyusb/examples/device/usbtmc/src/usbtmc_app.c new file mode 100755 index 00000000..8f87a6dc --- /dev/null +++ b/tinyusb/examples/device/usbtmc/src/usbtmc_app.c @@ -0,0 +1,329 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Nathan Conrad + * + * 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 +#include /* atoi */ +#include "tusb.h" +#include "bsp/board.h" +#include "main.h" + +#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 + }, + .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,ModelNumber,SerialNumber,FirmwareVer123456\r\n"; +//static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer and a bunch of other text to make it longer than a packet, perhaps? lets make it three transfers...\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 uint32_t idnQuery; + +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. + + +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 = 0; + + if(transfer_complete && (len >=4) && !strncasecmp("*idn?",data,4)) + { + idnQuery = 1; + } + 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 + { + 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; +} -- cgit v1.2.3