Allow multiple CDCs.

You must:

1) increase CFG_TUD_CDC in tusb_config.c (currently, in the core.)

2) define the additional Vserial ports "Adafruit_USBD_CDC portName(n)" (where n goes from 1 to CFG_TUD_CDC-1) (0 is "Serial")  "n" is a new addition to the constructor.

3) Use the "begin method" on the additional ports in "n" order.

There is a new example ../CDC/multiCDC that exercises the features.

Author: WestfW

examples/CDC/multiCDC/multiCDC.ino

@@ -0,0 +1,134 @@
+/*
+    This example demonstrates the use of multiple USB CDC/ACM "Virtual Serial" ports,
+    using Ha Thach's tinyUSB library, and the port of that library to the Arduino environment
+    https://github.com/hathach/tinyusb
+    https://github.com/adafruit/Adafruit_TinyUSB_Arduino
+
+    Written by Bill Westfield (aka WestfW), June 2021.
+    This code is released to the public domain (note that this is a different
+    license than the rest of the TinyUSB library and examples.)
+
+    The example creates three virtual serial ports, runs a non-blocking parser on
+    each one, and allows them to send messages to each other.  This is pretty useless,
+    and is relatively complex for an example, but it exercises a bunch of the CDC features.
+
+    The max number of CDC ports (CFG_TUD_CDC) has to be changed to at least 3, changed in
+    the core tusb_config.h file.
+*/
+
+#include <Adafruit_TinyUSB.h>
+#include "simpleparser.h"
+
+#define LED LED_BUILTIN
+
+/*
+      Create extra USB Serial Ports.  "Serial" is already created.
+*/
+Adafruit_USBD_CDC USBSer2(1);
+Adafruit_USBD_CDC USBSer3(2);
+
+Adafruit_USBD_CDC *ports[CFG_TUD_CDC] = { &Serial, &USBSer2, &USBSer3, NULL };
+
+void setup() {
+  pinMode(LED, OUTPUT);
+  // start up all of the USB Vitual ports, and wait for them to enumerate.
+  Serial.begin(115200);   // Do these in order, or
+  USBSer2.begin(115200);  //   "bad things will happen"
+  USBSer3.begin(115200);
+  while (!Serial || !USBSer2 || !USBSer3) {
+    if (Serial) {
+      Serial.println("Waiting for other USB ports");
+    }
+    if (USBSer2) {
+      USBSer2.println("Waiting for other USB ports");
+    }
+    if (USBSer3) {
+      USBSer3.println("Waiting for other USB ports");
+    }
+    delay(1000);
+  }
+  Serial.print("You are TTY0\n\r\n0> ");
+  USBSer2.print("You are TTY1\n\r\n1> ");
+  USBSer3.print("You are TTY2\n\r\n2> ");
+}
+
+
+// We need a parser for each Virtual Serial port
+simpleParser<80> line0(Serial);
+simpleParser<80> line1(USBSer2);
+simpleParser<80> line2(USBSer3);
+
+int LEDstate = 0;
+
+// Given an input port and an output port and a message, send it off.
+
+void sendmsg(Adafruit_USBD_CDC &out, Adafruit_USBD_CDC &in, char *msg) {
+  out.print("\r\nTTY");
+  out.print(in.getInstance());
+  out.print(": ");
+  out.println(msg);
+  out.flush();
+}
+
+// we've received a line on some port.  Check if it's a valid comand,
+// parse the arguments, and take appropriate action
+void parseMsg(Adafruit_USBD_CDC &in, parserCore &parser) {
+  int target;
+  enum {                    CMD_SEND, CMD_HELP, CMD_HELP2 };
+  int cmd = parser.keyword("send help ? ");
+  switch (cmd) {
+    case CMD_SEND:
+      target = parser.number();
+      if (target < 0 || target >= CFG_TUD_CDC || ports[target] == NULL) {
+        in.println("Bad target line");
+        return;
+      }
+      sendmsg(*ports[target], in, parser.restOfLine());
+      break;
+
+    case CMD_HELP:
+    case CMD_HELP2:
+      in.println("Available commands:\r\n  SEND N msg");
+      break;
+    default:
+      in.println("invalid command");
+      break;
+  }
+}
+
+void loop() {
+  if (line0.getLine()) {
+    parseMsg(Serial, line0);
+    line0.reset();
+    Serial.print("0> ");
+
+  }
+  if (line1.getLine()) {
+    parseMsg(USBSer2, line1);
+    line1.reset();
+    USBSer2.print("1> ");
+  }
+  if (line2.getLine()) {
+    parseMsg(USBSer3, line2);
+    line2.reset();
+    USBSer3.print("2> ");
+  }
+  if (delay_without_delaying(500)) {
+    // blink LED to show we're still alive
+    LEDstate = !LEDstate;
+    digitalWrite(LED, LEDstate);
+  }
+}
+
+// Helper: non-blocking "delay" alternative.
+boolean delay_without_delaying(unsigned long time) {
+  // return false if we're still "delaying", true if time ms has passed.
+  // this should look a lot like "blink without delay"
+  static unsigned long previousmillis = 0;
+  unsigned long currentmillis = millis();
+  if (currentmillis - previousmillis >= time) {
+    previousmillis = currentmillis;
+    return true;
+  }
+  return false;
+}

examples/CDC/multiCDC/simpleParser.cpp

@@ -0,0 +1,246 @@
+/*
+ * simpleParser
+ * Implement a command-line parser.
+ * Written 2014 by Bill Westfield (WestfW)
+ * refactored 2020
+ * Released to the public domain.
+ */
+
+#include "Arduino.h"
+#include "simpleParser.h"
+#include <avr/pgmspace.h>
+
+
+/*
+ *  Reset the line buffer
+ */
+void parserCore::reset ()
+{
+  memset(buffer, 0, lineLen);
+  inptr = 0;
+  parsePtr = 0;
+  termchar = 0;
+}
+
+/*
+ * getLine
+ * Read a line of text from Serial into the internal line buffer.
+ * With echoing and editing!
+ * Non-blocking.  Returns 0 until end-of-line seen.
+ */
+uint8_t parserCore::getLine ()
+{
+  int c;
+
+  c = S->read();
+  switch (c) {
+    case 127:
+    case CTRL('H'):
+      /*
+         Destructive backspace: remove last character
+      */
+      if (inptr > 0) {
+        S->print("\010 \010");
+        buffer[--inptr] = 0;
+      }
+      break;
+    case CTRL('R'):
+      /*
+         Ctrl-R retypes the line
+      */
+      S->print("\r\n");
+      S->print(buffer);
+      break;
+    case CTRL('U'):
+      /*
+         Ctrl-U deletes the entire line and starts over.
+      */
+      S->println("XXX");
+      reset();
+      break;
+    case CTRL('J'):
+    case CTRL('M'):
+      buffer[inptr++] = '\n';
+      S->println();     /* Echo newline too. */
+      return inptr;
+    case -1:
+      /*
+         No character present; don't do anything.
+      */
+      return 0;
+    default:
+      /*
+         Otherwise, echo the character and put it into the buffer
+      */
+      buffer[inptr++] = c;
+      S->write(c);
+  }
+  return 0;
+}
+
+/*
+ *  getLineWait
+ *  like getLine, but block until a complete line is read
+ */
+
+uint8_t parserCore::getLineWait (void)
+{
+  uint8_t status;
+
+  do {
+    status = getLine();
+  } while (status == 0);
+  return status;
+}
+
+
+bool parserCore::IsWhitespace (char c)
+{
+  return (c == ' ' || c == CTRL('I'));
+}
+
+
+
+bool parserCore::delim(char c)
+{
+  static const char Delimiters[] PROGMEM = "\r\n ,;:=\t";
+  if (c == 0 || strchr_P(Delimiters, c))
+    return true;
+  return false;
+}
+
+/*
+ * Number
+ *  Advance the token and parse a number.  Accept decimal, hex, octal.
+ */
+
+int parserCore::number()
+{
+  char *p = token();
+  if (p) {
+    return strtol(p, 0, 0);
+  }
+  return -1;
+}
+
+/*
+ * eol
+ * return true if we're at the end of the line.
+ */
+boolean parserCore::eol ()
+{
+  while (IsWhitespace(buffer[parsePtr])) { /* skip leading whitespace */
+    parsePtr++;
+  }
+  return buffer[parsePtr] == '\n' || buffer[parsePtr] == 0;
+}
+
+/*
+ *  cliTermChar
+ * return the termination character of the last token
+ */
+uint8_t parserCore::termChar ()
+{
+  return termchar;
+}
+
+/*
+ *  cliCharacter
+ */
+
+/*
+ * token
+ * A token is a set of non-delimiter characters ending at a delimiter.
+ * As a line is parsed from the internal buffer, parsePtr is advanced, and
+ *  the delimiters of parsed tokens are replaced with nulls.
+ * Note that a line always ends with the newline character AND a null.
+ */
+
+char *parserCore::token ()
+{
+  uint8_t i;
+
+  if (eol()) {  // reached the end of the line?
+    return NULL;
+  }
+  i = parsePtr;  // save start position of token
+  while ((!delim(buffer[parsePtr])) && (parsePtr < lineLen)) {
+    parsePtr++; // advance pointer till we hit a delimiter.
+  }
+  termchar = buffer[parsePtr];
+  buffer[parsePtr++] = 0;  // replace the delimiter with null
+  return &buffer[i];  // convert position to pointer for retval
+}
+
+/*
+ * Match the next token with a list of keywords.
+ * The list of keywords is in PROGMEM, separated by spaces.
+ * returns either the position of the found keyword (0..n),
+ * PARSER_NOMATCH, PARSER_AMB, or PARSER_EOL at the end of line
+ */
+int8_t parserCore::keyword (const char *keys)
+{
+  char *p = token();
+  char *thisKey = (char *)keys;
+  int8_t i = 0, match, first=PARSER_NOMATCH;
+  if (!p)
+    return PARSER_EOL;
+
+  while (pgm_read_byte(thisKey)) {
+    match = tokcasecmp(p, thisKey);
+#if defined(DEBUG) && DEBUG
+    extern char spbuffer[];
+    sprintf(spbuffer, "key='%s', p='%s', match = %d\n", thisKey, p, match);
+    S->print(spbuffer);
+#endif
+    if (match == CMP_MATCH) {
+      return i;
+    }
+    while (pgm_read_byte(thisKey) > ' ') {
+      thisKey++;  // advance to next keyword
+    }
+    thisKey++;  // skip delimiter
+    if (match == CMP_PARTIALMATCH) {
+      // There was a partial match; check for another...
+      if (first != PARSER_NOMATCH) {   // already another match?
+        return (PARSER_AMB);
+      } else {
+        first = i;
+        continue;
+      }
+      return i;  // match
+    }
+    i++; // next keyword
+  }
+  return first;
+}
+
+/*
+ * tokcasecmp
+ * tokcasecmp is like strcasecmp_P, except that the strings are terminated
+ * by any char < 32.  Return value is 0 for match, or pointer to the delimiter
+ * for non-match (to expedite comparing against strings of targets.)
+ */
+uint8_t parserCore::tokcasecmp(const char *tok, const char *target)
+{
+  char tokc, keyc;
+  const char *t = (char *)target;
+
+  do {
+    tokc = toupper(*tok++);
+    keyc = toupper(pgm_read_byte(t++));
+    // tok++; t++;
+    if (tokc == 0) {
+      // End of token; see if end of keyword as well
+      if (keyc <= ' ') {
+        return CMP_MATCH;  // both ended - exact match
+      }
+      return CMP_PARTIALMATCH; // keyword is longer - partial
+    }
+    // Not end of token
+    if (keyc <= ' ') {
+      return CMP_NONMATCH;  // key ended before tok - non match
+    }
+  } while (tokc == keyc);
+  return CMP_NONMATCH;  // neither string ended, but non-match
+}