Using USB Serial Communication

 
void setup()
{
  Serial.begin(9600); // USB is always 12 Mbit/sec
}

void loop()
{
  Serial.println("Hello World...");
  delay(1000);  // do not print too fast!
}

The Teensy does not actually become a serial device until your sketch is running, so you must select the serial port (Tools -> Serial Port menu) after your sketch begins.

Standard Serial Functions

Serial.begin()

Serial.print() and Serial.println()

 
  // Serial.print() can print many different types
  int number = 1234;
  Serial.println("string");     // string
  Serial.println('a');          // single character
  Serial.println(number);       // number (base 10 if 16 or 32 bit)
  Serial.println(number, DEC);  // number, base 10 (default)
  Serial.println(number, HEX);  // number, base 16/hexidecimal
  Serial.println(number, OCT);  // number, base 8/octal
  Serial.println(number, BIN);  // number, base 2/binary
  Serial.println(number, BYTE); // number, as a single byte
  Serial.println(3.14);         // number in floating point, 2 digits

Serial.write()

Serial.available()

On a standard Arduino, Serial.available() tends to report individual bytes, whereas large blocks can become instantly available with Teensyduino. See Receive Buffering below for details.

Serial.read()

 
  if (Serial.available()) {
    incomingByte = Serial.read();  // will not be -1
    // actually do something with incomingByte
  }

Serial.flush()

Teensy USB Serial Extensions

Serial.send_now()

Serial.dtr()

 
void loop()
{
  pinMode(6, OUTPUT);      // LED to show if a program is using serial port
  digitalWrite(6, HIGH);   //   (active low signal, HIGH = LED off)
  while (!Serial.dtr()) ;  // wait for user to start the serial monitor
  digitalWrite(6, LOW);
  delay(250);
  Serial.println("Hi there, new serial monitor session");
  while (Serial.dtr()) {   // wait for the user to quit the serial monitor
    Serial.print('.');
    delay(500); 
  }
}

Serial.rts()

For programs that use RTS to signal some useful information, you can read it with this function.

Serial.baud()

Serial.stopbits()

Serial.paritytype()

Serial.numbits()

USB Buffering and Timing Details

Transmit Buffering

On a Teensy, Serial.print() writes directly into the USB buffer. If your entire message fits within the buffer, Serial.print() returns to your sketch very quickly.

Both Teensyduino and the FTDI chip hold a partially filled buffer in case you want to transmit more data. After a brief timeout, usually 8 or 16 ms on FTDI and 3 ms in Teensyduino, the partially filled buffer is scheduled to transmit on the USB.

The FTDI chip can be made to immediately schedule a partially filled buffer by toggling any of the handshake lines (which are not connected on a standard Arduino board). It can also be configured (by the PC device driver) to schedule when an "event character" is received. Normally it is difficult to control when the FTDI chip schedules its partially filled transmit buffer.

Teensyduino immediately schedules any partially filled buffer to transmit when the Serial.send_now() function is called.

All USB bandwidth is managed by the host controller chip in your PC or Mac. When a full or partially filled buffer is ready to transmit, it actual transmission occurs when the host controller allows. Usually this host controller chip requests any scheduled transfers 1000 times per second, so typically actual transmission occurs within 0 to 1 ms after the buffer is scheduled to transmit. If other devices are using a lot of USB bandwidth, priority is given to "interrupt" (keyboard, mouse, etc) and "isychronous" (video, audio, etc) type transfers.

When the host controller receives the data, the operating system then schedules the receiving program to run. On Linux, serial ports opened with the "low latency" option are awakened quickly, others usually wait until a normal "tick" to run. Windows and MacOS likely add process scheduling delays. Complex runtime environments (eg, Java) can also add substantial delay.

Receive Buffering

 
void loop()
{
  // On a serial-based Arduino, bytes tend to arrive one at a time
  // so this while loop usually only processes 1 byte before allowing
  // the rest of the loop function to do its work
  while (Serial.available()) {
    incomingByte = Serial.read();
    // do something with incomingByte
  }
  // do other unrelated stuff
  time_sensitive_task1();
  another_urgent_thing();
  still_yet_even_more_stuff();
}

 
void loop()
{  
  // On a Teensy, large groups of bytes tend to arrive all at once.
  // This bytecount prevents taking too much time processing them.
  unsigned char bytecount = 0;
  while (Serial.available() && bytecount < 10) {
    incomingByte = Serial.read();
    // do something with incomingByte
    bytecount++;
  }
  // do other unrelated stuff
  time_sensitive_task1();
  another_urgent_thing();
  still_yet_even_more_stuff();
}