Seetron Tech

Cleaner Arduino Coding with Streaming

2012-02-24T13:33:00.002-08:00

Arduino Serial.Print() and Serial.Write() instructions multiply like bunnies in applications that use serial output for debugging or to drive serial displays. If only related instructions, variables and strings could be neatly packaged for serial output using a single instruction...Turns out that they can, and with zero code overhead. All that's required is the Streaming library from Arduiniana.org.

Once you copy the Streaming folder into your Arduino Libraries directory, you can #include <Streaming.h> into your programs and go from this:

Serial.Print("x= ") ;
Serial.Print(varX) ;
Serial.Print(" y= ");
Serial.Print(varY);
//ad nauseum

to this:

Serial<<"x= "<<varX<<" y= "<<varY;

Slick, eh? Below is an example that drives a BPI-216 serial LCD or GLO-216Y/G serial OLED. (Although the GLOs have a larger, more extensive instruction set, they understand a subset of LCD instructions, too.)

/*
Streaming Example for BPI-216 Serial LCD 
 (Will run on GLO-216Y/G, too, thanks to 
 limited BPI emulation.)
 
 Arduiniana.org offers an Arduino library that enables C++
 style "streaming" notation for serial output. Streaming 
 really helps tighten up multi-part Prints by allowing 
 you to combine multiple strings, chars, bytes and 
 variables into a single line that get 'funneled' into 
 the serial object by a series of << symbols. 
 */

#include <SoftwareSerial.h>  // New SoftSerial, Arduino v1.0+
#include <Streaming.h>

#define rxPin 255       // Not used, so set to invalid pin #
#define txPin 3         // Hook BPI/BPK SER input to Arduino pin 3.
#define inverted 1     // Set serial-output polarity to inverted

//BPI Clear-Screen instruction, plus a redundant Position-to-0
//instruction for timing purposes. 
#define CLS "\xFE\x01\xFE\x80"
//BPI Go-To-Start-of-Line-2 instruction. 
#define L2 "\xFE\xC0"

/* 
 Set up a new serial output using the pin definitions above. Note the  
 "inverted," which instructs SoftwareSerial to output BPI/BPK-compatible 
 inverted-TTL serial (like RS-232, but without the +/- voltage swing).
 */
SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin, inverted);
// The Serial dot-Print method handles all sorts of data, including 
// automatic conversion of floats to strings (with two digits after
// the decimal point). 
float pi = 3.14159; // Print prints floats.
int two = 2 ;  // Print also prints ints (as does <<) 

void setup()  {
  // define pin modes for tx, rx:
  digitalWrite(txPin, LOW);   // Stop bit state for inverted serial
  pinMode(txPin, OUTPUT);
  mySerial.begin(9600);    // Set the data rate
  delay(1000);              // wait.

  // Here's the magical "Streaming" part. The line that follows 
  // replaces seven lines of "mySerial.Print(...)" instructions. 

  mySerial<<CLS <<"Pi is " <<pi <<L2 <<"Good "<<two <<" know.";  
}

void loop() {
  // ...
}

Arduino ISR Clock Demo

2012-02-07T12:48:00.000-08:00

The engineering blog engblaze.com recently posted a great tutorial on using Arduino/AVR timer interrupts. This led to a lunch-hour challenge: To convert their once-a-second LED blinker into a minimal 7-segment-style clock display using our GLO-216G serial OLED. Mission accomplished:

The clock program is minimal. All I did was take the excellent Engblaze timer/interrupt framework and drop in functions to keep time and do the serial stuff to drive the display. What may be of interest to Arduino programmers is the way that I organized the time values: Rather than declare separate variables to hold the hours, minutes and seconds, I used a single char array.

Since a char array that ends with null/zero in the last position is also a string for the purposes of Arduino serial routines, this approach allowed me to avoid the typical Arduino bugaboo of needing multiple serial "print" instructions to print a list of variables.

/* Simple Clock Demo for GLO-216Y/G
 A tutorial at engblaze.com shows how to 
 set up AVR timers to fire an interrupt at 
 regular intervals--in this case 1.0000 second. 
 The engblaze program toggles an LED every 
 second. This version, for the Arduino Uno, 
 runs a 24-hour clock and shows the time on 
 a GLO-216Y/G serial OLED display. 
 
 =Program is written for GLO-216Y/G with intact 
 Spol jumper (inverted serial). Connect GLO
 SER to Arduino pin 3; power to +5 and GND. 
 */

// avr-libc library includes for timer ISR
#include <avr/io.h>
#include <avr/interrupt.h>

// Software Serial Stuff
// 
#include <SoftwareSerial.h>
#define rxPin 255       // Not used, set to invalid #
#define txPin 3         // GLO input to this Arduino pin
#define inverted 1     // If GLO-216 Spol jumper is intact  

// Instructions sent to GLO-216Y/G at startup. 
// 0x0c = clear the screen.
// 0x03,0x02,0x02,0x02 = Set big font. 
// 0x19 = Use the 7-segment number font.
char const gloSetup[] = {
  0x0c,0x03,0x02,0x02,0x02,0x13,0x00 } 
;

// Dual-use char-array string ========================== 
// As an array, it stores the digits of the time
// hh mm ss. Functions below increment the digits as 
// appropriate for their units (0-59 for minutes and 
// seconds, 0-23 for hours). Digits are stored as 
// ASCII characters rather than raw values, allowing for 
// the string to be printed without further processing. 
// In addition to the digits, the string also contains
// a pair of ':' characters, and starts with the GLO
// home-cursor instruction 0x01. Packing the digits, 
// colons and formatting instruction together in one 
// string allows the time to be updated in one "print."
char hmsTime[10] = {
  0x01,
  '1','2',':','4','1',':','5','0',0x00} 
;  

// Defining names for the digit positions in the 
// time string makes it easier to read the functions 
// that increment the time
#define sOnes 8    // Ones digit of seconds. 
#define sTens 7    // Tens digit of seconds. 
#define msColon 6  // ':' between minutes and seconds.
#define mOnes 5    // Ones digit of minutes.
#define mTens 4    // Tens digit of minutes. 
#define hmColon 3  // ':' between hours and minutes.
#define hOnes 2    // Ones digit of hours.
#define hTens 1    // Tens digit of hours.

// Establish a soft serial port using the pin definitions above.
SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin, inverted);

// Set up the Soft Serial output and send the GLO its setup 
// instructions. Then, using code copied from engblaze.com, 
// set up a timer to fire an ISR at precise 1-second intervals. 
void setup()
{
  digitalWrite(txPin, LOW);   // Stop bit state for 
  pinMode(txPin, OUTPUT);    // 
  mySerial.begin(9600);
  delay(500);              // wait 
  mySerial.print(gloSetup);

  // initialize Timer1
  cli();          // disable global interrupts
  TCCR1A = 0;     // set entire TCCR1A register to 0
  TCCR1B = 0;     // same for TCCR1B

  // set compare match register to desired timer count:
  OCR1A = 15624;
  // turn on CTC mode:
  TCCR1B |= (1 << WGM12);
  // Set CS10 and CS12 bits for 1024 prescaler:
  TCCR1B |= (1 << CS10);
  TCCR1B |= (1 << CS12);
  // enable timer compare interrupt:
  TIMSK1 |= (1 << OCIE1A);
  // enable global interrupts:
  sei();
}

// Nothing in the loop. All the action is in the ISR.  
void loop()
{
  // Put your code here.  
}

// Timer fires this ISR every second. 
ISR(TIMER1_COMPA_vect)
{
  mySerial.print(hmsTime);  // print the string. 
  incSeconds() ;            // update for next time. 
}

// Timekeeping routines =======================
// The digits of the hours,  minutes and 
// second are stored as characters in a char-
// array string. Since the only math needed is 
// increment (and carry-the-one), it's efficient
// to just work with the chars rather than 
// regular integers (or bytes, etc.). 
// ============================================

//Increment seconds. If seconds value exceeds
//59, increment minutes. 
void incSeconds() {
  hmsTime[sOnes] += 1 ;
  if (hmsTime[sOnes] > '9') {
    hmsTime[sOnes] = '0' ;
    hmsTime[sTens] += 1 ;
    if (hmsTime[sTens] > '5') {
      hmsTime[sTens] = '0' ;
      incMinutes(); 
    }
  }
}

//Increment minutes. If minutes value exceeds
//59, increment hours. 
void incMinutes() {
  hmsTime[mOnes] += 1 ;
  if (hmsTime[mOnes] > '9') {
    hmsTime[mOnes] = '0' ;
    hmsTime[mTens] += 1 ;
    if (hmsTime[mTens] > '5') {
      hmsTime[mTens] = '0' ;
      incHours() ;       
    }
  }
}

//Increment hours. If hours value exceeds
//23, rollover to 0. 
void incHours() {
  if (hmsTime[hTens] == '2' && hmsTime[hOnes] == '3')
  {
    hmsTime[hOnes] = '0' ;
    hmsTime[hTens] = '0' ;  
  }
  else
  {
    hmsTime[hOnes] += 1 ;
    if (hmsTime[hOnes] > '9') {
      hmsTime[hOnes] = '0' ;
      hmsTime[hTens] += 1 ;
    }   
  }     
}

Custom Character Demo with Serial Sender

2012-01-19T12:24:00.000-08:00

Serial Sender, our free Windows tool for sending text and data via a comm port or USB adapter, has been updated to v1.2. Previous versions allowed you to send arbitrary bytes by wrapping their decimal values in angle brackets, like so: <65>. The update allows bytes expressed as hex: <0x41>. Some values, particularly bit patterns, are easier to work with in hex. Coincidentally, a user asked for guidance on defining custom characters for the GLO-216 with Serial Sender, so here it is:

Our serial OLED displays, GLO-216 and GLO-416 superficially resemble serial LCD modules. They fit the same mounting holes, have similar screen sizes, etc. But they are entirely different (superior!) displays, with better brightness, contrast and efficiency, support for multiple, large font sizes and a convenient serial interface.

One minor area of improvement is custom-character support. LCDs have eight, non-reusable custom characters—GLOs have 16 reusable custom characters. By "reusable" I mean that the same character can be printed and redefined on the same screen. GLOs allow this, but LCDs do not. When you redefine an LCD custom character, previously printed instances of that character change to the new pattern, garbling your screen.

GLO-216/416 Custom Characters. Custom characters occupy character codes 128 - 143 in the GLO character set. Defaults look like this:

Suppose we want to change character 128, the large degree ° symbol, to a padlock icon to indicate limited access or write-protection. First stop would be the Seetron site to use the online bitmap designer. Clickety-click, and the icon is designed:

Highlight the bitmap data in either format (decimal or hex) and copy it to the clipboard. Then open Serial Sender and type in the redefine-character instruction as described in the programmer's reference. Paste the bitmap data into the instruction. Result:

Click Send to download the pattern to the display. Repeat the process, making an open padlock in the bitmap designer, pasting the data into Serial Sender, and changing the ESC instruction from D0 to d0 (lowercase 'd'). This targets custom character 8, which lives at code 136.

Now the fun part, testing the new characters. Clear the text box, type and Send:

<L,128> Locked<M,136> Unlocked.

So far, all of this is very similar to stuff you can do with an LCD. Let's try something specific to the GLO-216— using the font-size capabilities. Type and send:

<L,C,B,128> Locked<C,P,74>unlock<P,89,126>exit

How about a big icon? Type and send:

<L,C,B,B,B,128,C> Access Denied<P,83>Abort/Retry?

If your custom characters are useful, you may want to save them to the GLO's flash memory. Easy: type and send <ESC>x0 (that's a lowercase 'x' and the number zero).

I've gone pretty fast here, presenting the Serial Sender sequences without much explanation. Basically it boils down to this: Instructions are listed in our documentation by control code, decimal code and hex code. You can use any of these sandwiched between < > brackets in Serial Sender, much as you can define constants in various ways in a programming language. Using Serial Sender to understand and debug sequences of instructions can be a real time saver. And of course if you still have questions, email tech at seetron dot com.

Odometer-effect Counter with Arduino and GLO-216 Serial OLED

2012-01-05T13:53:00.000-08:00

Using a custom character in an unusual way, you can create a fun rolling-odometer visual effect with a GLO-type serial OLED. We've posted a sample Arduino program that does the trick. Here's a quick video:

Program listing is after the jump. (It's been tweaked slightly since first publication; now uses PROGMEM to store the digit bitmaps and instructions in program memory, sparing precious Arduino RAM.)

/*
Arduinodometer!
 (GLO-216 and Arduino Uno)
 This program demonstrates a fun visual effect in which the final digit 
 of a counter is animated to 'roll up,' like the tenths-of-a-mile digit  
 on a mechanical odometer. 
 
 Connect the GLO- to the Arduino +5 and GND, with serial input from pin  
 3 (using NewSoftSerial library or Arduino v1.0+). If the Spol jumper on 
 your GLO- has been cut (for UART-direct input), change the parameter 
 "inverted" to "noninverted" in the program line: 
 SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin, inverted); 
 */

#include <avr/pgmspace.h>    // needed for PROGMEM
#include <SoftwareSerial.h>  // use any pin for serial out

#define rxPin 255      // Not used, set to invalid pin #
#define txPin 3        // Plug GLO's serial input  into this pin.
#define inverted 1     // If GLO- Spol jumper is intact (COM-polarity)
#define noninverted 0  // If GLO Spol jumper is cut (UART polarity)
#define odoChar 0x8F   // Custom character 15, at ASCII 143

// Bitmaps for the digits "0" - "9". Using PROGMEM to store them 
// in Flash. This saves 80 bytes of Arduino RAM (at the expense of 
// some code overhead). 
const byte digitPatterns[] PROGMEM = {
  0x0E,0x11,0x13,0x15,0x19,0x11,0x0E,0x80,  // 0
  0x04,0x0C,0x04,0x04,0x04,0x04,0x1F,0x80,  // 1
  0x0E,0x11,0x11,0x02,0x04,0x08,0x1F,0x80,  // 2
  0x1F,0x02,0x04,0x02,0x01,0x11,0x0E,0x80,  // 3
  0x02,0x06,0x0A,0x12,0x1F,0x02,0x02,0x80,  // 4
  0x1F,0x10,0x1E,0x01,0x01,0x11,0x0E,0x80,  // 5
  0x06,0x08,0x10,0x1E,0x11,0x11,0x0E,0x80,  // 6
  0x1F,0x01,0x02,0x04,0x08,0x08,0x08,0x80,  // 7
  0x0E,0x11,0x11,0x0E,0x11,0x11,0x0E,0x80,  // 8
  0x0E,0x11,0x11,0x0F,0x01,0x02,0x06,0x80   // 9
} 
;

// This program includes a GLO-216 instruction that expects 8 bytes of data.
// If the program is reset during this download, the GLO would consume 
// our setup instructions thinking they were the expected data. So we'll 
// feed it some harmless characters as insurance. After that, clear
// the screen (0x0C), set the tall 1x16 font (0x03,0x02) and specify
// text-style numbers (0x14).
const prog_char clsSetBigFont[ ] PROGMEM = {
  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,  //reset insurance
  0x0C,0x03,0x02,0x14,0x00 } 
;

// This instruction consists of ctrl-A, ctrl-R, and the
// text number "6". Translation: 'Move to screen position 0,
// then right-align the number that follows in a 6-character 
// field.' Starting at position 0 and moving backward with ctrl-R
// causes the text to align to the righthand end of the screen.
const prog_char setPosRightAlign[ ] PROGMEM = {
  0x01,0x12,0x36,0x00} 
;

// Instruction ESC d 7, sets up redefinition of 
// custom character 15 (ASCII 143). The eight bytes sent
// after this instruction define the character bitmap.
const prog_char defineCC[ ] PROGMEM = {
  0x1B,0x64,0x37,0x00} 
;

// Main-count variable: 0-65535
unsigned int odoCount = 1024 ;

// RAM buffer for strings used by serial output, which can't 
// directly access strings stored in program memory with PROGMEM.
char buffer[15] ;

// Define a new serial port using the pin definitions above.
// Using inverted serial; if Spol is cut, change to noninverted.
SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin, inverted);

// SETUP: 
// Initialize the serial output, send some bytes to complete a 
// pending instruction, clear the screen and set the font, then 
// print a label. 
void setup() {
  digitalWrite(txPin, LOW);   // Stop bit state for inverted serial
  pinMode(txPin, OUTPUT);
  // set the data rate for the SoftwareSerial port
  mySerial.begin(9600);
  // give the GLO ample time to start up
  delay(500); 
  strcpy_P(buffer, clsSetBigFont);
  mySerial.print(buffer) ;
  mySerial.print("Odometer:") ;
}

// LOOP: 
// Print the main count, invoke the function that updates the 
// rolling custom-character pattern, and update the main count
// when the final digit rolls over. 
void loop() {
  // right align at the end of the display
  strcpy_P(buffer, setPosRightAlign);
  mySerial.print(buffer);
  // print the main count
  mySerial.print(odoCount) ;
  // now print the rolling final digit
  mySerial.write(odoChar) ;
  // roll up the last digit, and if it has 
  // rolled over to 0, increment main count
  if (incOdoChar() == 0) { 
    odoCount++ ; 
  }
  delay(25) ;
}

// incOdoChar() 
// Moves a pointer (odoIndex) through the digitPattern[]
// array to redefine the odo-digit custom character.
// This causes the "0" bitmap to scroll up row-by-pixel-
// row to be replaced by the "1" bitmap, which scrolls up...
// Function returns the index value; when this rolls over 
// to zero, the odoCount value should increment, just like 
// a real mechanical odometer. 
byte incOdoChar() {
  static byte odoIndex = 0 ;
  // send the instruction to redefine custom character
  strcpy_P(buffer, defineCC);
  mySerial.print(buffer);
  // send the eight-byte bitmap of the new CC pattern
  for (int i=0; i < 8; i++) {
    //retrieve the next byte from the flash/program memory table
    //and write it to the serial output 
    mySerial.write(pgm_read_byte(&digitPatterns[(i+odoIndex)%80]));
  }
  // increment for next time-- %80 to restrict 
  // to 0-79 (valid index range of digitPatterns[])
  odoIndex = ++odoIndex%80 ;
  // return index to signal rollover (0)
  return odoIndex ;
}

Arduino "Hello World" for BPI-216 Serial LCDs

2011-12-28T07:57:00.000-08:00

Version 1.0 of the Arduino software includes an update to the SoftwareSerial library, which (among other things) can output inverted-TTL serial that works with our BPI-, BPK-, and BPP- series devices. Here's a quick example sketch:

/*This program uses the updated SoftwareSerial distributed in v1.0 of the 
 Arduino software. Users of earlier versions must download NewSoftSerial. */
#include <SoftwareSerial.h>

#define rxPin 255       // Not used, so set to invalid pin #
#define txPin 3         // Connect BPI/BPK's serial input to this Arduino pin.
#define inverted 1     // In setup, 1=inverted, 0 (or no entry)=noninverted

const char clearScreen[ ] = {
  254,1,254,128,0};
const char message[ ] = "Hello World!" ;

/* 
Set up a new serial output using the pin definitions above. Note the argument 
"inverted," which instructs SoftwareSerial to output BPI/BPK-compatible 
inverted-TTL serial (like RS-232, but without the +/- voltage swing).
*/
SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin, inverted);

void setup()  {
  // define pin mode for tx:
  digitalWrite(txPin, LOW);   // Stop bit state for inverted serial
  pinMode(txPin, OUTPUT);
  mySerial.begin(9600);    // Set the data rate
  delay(10);              // wait (does not seem to be needed w/ Arduino v1.0)
  mySerial.print(clearScreen);
  mySerial.print(message);  
}

void loop() {
  // ...
}

Drop-in OLED Replacement for BPI-216 Serial LCDs

2011-12-07T07:13:00.001-08:00

Would you like to upgrade from a BPI-216 serial LCD to a GLO-216Y/G serial OLED, but can't make any changes to your product's firmware? Help is on the way—contact tech@seetron.com for information on the BGL-216 firmware modification.

GLO-series OLEDs are brighter, more contrasty, tolerant of a wider range of temperature, and offer neat features like larger font sizes, instant-on startup screen, etc. They even understand a significant subset of BPI-style instructions. With a few minor changes, most designs built around the BPI-216 can enjoy a significant upgrade.

Minor changes? Changes?

Turns out that in some cases the firmware is carved in stone. A consultant absconded with the source code, or the code exists but is indecipherable, written in an obsolete language, or too tangled to safely modify. The design is eternally shackled to the BPI-216.

A number of loyal customers have found themselves in this fix, so we've developed alternative firmware for the GLO-216Y/G that emulates, as accurately as possible, the behavior of its LCD predecessors. Quirks and all. GLOs with the emulation firmware will be offered under part number BGL-216Y (yellow) and BGL-216G (green). The new firmware is almost complete; we're researching the last few oddities of the LCD-controller architecture to make sure that the emulation is as accurate as possible.

If a BPI-compatible OLED would help you out of a jam, contact tech@seetron.com for more information.

SGX-120L Bitmap Tool

2011-11-23T12:10:00.001-08:00

The SGX-120L serial graphics display can store up to 17 full screen bitmaps in flash memory; two of the bitmaps make up the display's font, the other 15 can be displayed using the ESC-E instruction (or used as alternative fonts).

The most practical way to load bitmaps into the SGX has always been to create .BMP files on a PC (using the free Paint program included with Windows), but our conversion/downloading software has been pretty crude, to say the least. With the introduction of a new SGX coming up, we decided to freshen up the bitmap tool:

The program, which runs under '95 through Windows 7, is available for download here (New SGX Tools...).

To use the tool, extract it from its ZIP archive to a convenient spot on your PC (Desktop is good; a thumb drive might be better). No installation is required, but the program does create a couple of small files in the same directory. These files save your comm port setting and downloaded-file list between uses of the program.

Using the program is pretty straightforward, but here's a quick rundown:

Connect the SGX to your PC serial port.
Set the Comm Port box to match the serial port number you're using.
If the SGX is a version 1.0 model, set the 2400/9600 (bps) switch to 9600.
If the SGX has previously been write-protected, undo that with the config tool.
Click Load .BMP File and find a 120x32-pixel monochrome BMP file to download to the SGX.
Click Send to SGX and (assuming the file and comm port are OK) the picture will appear on the display.

To save a picture to the SGX, put a check in the box Save to SGX Flash Memory and select the page number in the box below that. Don't pick page 0 or 1 unless you are replacing the font! Now when you click Send to SGX, the bitmap will be downloaded and memorized to flash inside the display.

As you download and save pictures to the SGX, the program makes a list of BMP files and SGX screen pages and saves it to a text file called sgxscreens.lst. This file is located in the same directory as the program. If you need to set up multiple SGXes with the same bitmaps in the same screen pages, this file helps automate the job. Here's how:

Launch the bitmap tool and download the desired bitmaps to the desired screen pages of the SGX. When that's done, rename the list file sgxscreens.lst to something like mysgxscreens.lst. All that's important is that you keep the extension .lst. (You can examine the file in Notepad or another text editor to check on your files.)

To download the file list to another SGX, click Load List and select your .lst file. The preview area will be cleared in preparation for the series of downloads, like so:

When the SGX is connected, click Send to SGX and the program will download the files from your list and save them to the same SGX flash pages as the original, manual downloads. As the download progresses, each bitmap will appear in the preview:

When the download is complete, a status message appears:

To load another SGX, click Send to SGX again.

SGX v2 Confirmation Screens. The new SGX-120L version 2.0 (v2) can optionally display a confirmation screen to show whether a memory operation succeeded. In the case of screen downloads, if write-protection is in effect, the SGX will not store the downloaded screen. With the original, v1 SGX, you'd have to check to ensure that a bitmap was actually stored (or be certain you hadn't set write protection and forgotten about it). The v2 can provide a confirmation screen instead:

Confirmation screens are only available during manual downloads; during list-file downloads the images flip by too quickly to make the confirmations useful. Here, it would make sense to either freshly configure the display with write-protection off, or try a single, manual download to test write-protection status before running a list-based download.

Raw-Data Secret Knock. The Comm Port box accepts numbers from 1 to 99, but since ports are assigned sequentially starting at Comm 1, it seems unlikely that many users will have ports into the high double-digits. So Comm Port "99" has been appropriated to write the raw bitmap data to the clipboard. You'll get 30 lines of text with values in hexadecimal format that can be pasted into a text editor for use in a program. If you load a list file and select port 99, the program will put each bitmap on the clipboard with pauses in between to allow you to paste the data like so:

SGX-120L Configuration Tool

2011-11-23T11:08:00.001-08:00

The SGX-120L serial graphics LCD has several configuration settings that control the display's default startup behavior. You can set the SGX to start with the backlight on or off, blank or with a startup screen, with a particular font size, etc. Setting these options requires adding up the option numbers and sending them to the display using the ESC-W instruction (documented here).

Since we're getting ready to roll out a new version of the SGX, we decided to make a little GUI tool to make configuration easier. It's available for download here (New SGX Tools...). Here's how it looks in XP dress (works with '95 through Windows 7):

To use the tool, extract it from its ZIP archive to a convenient spot on your PC (Desktop is good; a thumb drive might be better). No installation is required, but the program does create a small file called sgxconfig.dat in the same directory. This file saves your settings between uses of the program.

To send a configuration instruction to the SGX:

If version 1.0, set the 9600/2400 switch to 9600 and SET/RUN to SET.
If version 2.0, make sure that the Dsu (display setup) jumper is uncut.
Identify the port to which the SGX is connected to and set Comm Port to match.
Pick your options and click Send. They'll take effect the next time the SGX powers up.

A couple of minor version-related differences are worth highlighting:

Write Protection. On the original, v1 SGX, write protection of stored screens was all or nothing, and it was disabled by default. As a result, users would occasionally replace screens 0 and 1 (which are the default font) with some other bitmap, causing text to print in hieroglyphics!

The new v2 SGX guards against fonticide with an additional layer of write protection. Now, screen pages 2 through 16 are writeable by default, but you must explicitly disable font write protection before you can replace screens 0 and 1.

Although there are four possible combinations of the two write-protect bits, only three are valid:

Allows writes to screen pages 2-16; blocks writes to the default font screens (screens 0, 1).

No writes allowed.

Allows writes to all screen pages (0-16) including font (screens 0, 1).

What about both boxes checked? The tool won't permit it, because it would imply (incorrectly) that only writing to the font screens is allowed. No such mode exists. If you were to input this combination manually using ESC-W, it would be equivalent to the middle option, no writes at all.

A reminder: If you're using the tool with one of the gajillion or so v1 SGXes out there, the only valid option is 'write protect all.'

SGX Confirmation. Another new feature of the v2 SGX is the confirmation screen for memory operations. When you send new settings to the display it just quietly memorizes them. To confirm the download, you'd generally have to cycle the power and check for the new settings.

The v2 SGX will (optionally) display a screen to acknowledge successful reception of a config instruction. It can also remind you in case you've previously cut the display setup (Dsu) jumper intending to prevent configuration changes. Here are the screens:

SGX-120L Graphics LCD Upgrade Sneak Peek

2011-11-15T07:21:00.001-08:00

We're getting ready to roll out version 2.0 of the workhorse SGX-120L serial graphics LCD. The new docs are online and offer a preview of the update.

New tools are also in the works to make it easier to configure the display and load bitmap graphics. In upcoming posts we'll introduce the new stuff and offer some tips on getting the most out of SGX applications.

The OLED Revolution will be Customized!

2011-09-15T14:59:00.000-07:00

Browsing a science magazine's site, I spotted an ad that depicted a character-type LCD, but was obviously a slick computer-graphics rendering. I say obviously because the message used some font tricks, like THE printed vertically, that can't quite be accomplished with text LCDs.

But they're dead easy with our GLO-416Y serial OLED.

Here's what I did: Using our custom-character editor, I made the vertical THE out of a pair of custom characters. Then I fired up Serial Sender and downloaded the bit patterns to the GLO. The instructions (as sent from Serial Sender's text box) looked like this:

<ESC>D0<128,128,145,149,149,159,128,159>
<ESC>D1<132,132,159,128,144,159,144,128>
(If that's Greek to you, check out the programmer's reference here.)

Now, I could print my sideways THE by placing the first custom character (ASCII 128 dec) on the line above the second (129). Now all I needed was a slogan to go with it. After some fiddling in Serial Sender, I came up with the mini-manifesto in the picture. The Sender string is like so:

<L,C,128,M,129,B>OLED REVOLUTION<B,B>@SEETRON

In GLO control characters, that's clear the screen, set default font, print a custom char, carriage return, 'nuther custom char, increase font size, print OLED REVOLUTION, increase font size again, print @SEETRON.

Arduino Demo for GLO-416Y Serial OLED

2011-09-06T15:34:00.000-07:00

There's an excellent hands-on evaluation of the new GLO-416Y serial OLED over at the elabz.com blog. The demo program uses an Arduino controller to read an analog value and display it on the OLED. While you're there, browse through the blog—lots of good ideas.

Sharing a Serial Output Pin During Development

2011-09-01T15:51:00.000-07:00

Some interactive microcontrollers (BASIC Stamp, Arduino, etc.) have dedicated serial I/O pins used to communicate with the PC during programming. Is it OK to use these pins to drive a serial display? Maybe, sometimes, sorta...if you're willing to accept the side effects during development.

When you hit Run or Download in your development environment, the program is compiled or tokenized and shipped off to the microcontroller. There's some back-and-forth communication between the micro and the PC during this process. If a serial display is connected to the serial-output pin that's being used for this communication, it's receiving a bunch of nonsense that may include data and instructions that affect its operation.

Case in point: a GLO-416Y (set for noninverted serial, SPol jumper cut), is connected to the TX pin of an Arduino. You compile your program and hit Download. A bunch of nonsense flashes by on the GLO screen, and when the program executes the screen is dim, the font size is wrong, and the first few bytes sent to the display are dropped. Curious, you cycle the power to see what happens, and the program runs perfectly. What gives?

The issue is that during the download, among the bytes exchanged between the PC and Arduino, were the values 0x0F and 0x02, and the sequence 0x1B, 0x44, 0x33... at the end. Those values are interpreted by the display as instructions to dim the display, alter the font size and begin a download of bytes for a custom character. Cycling the power flushes this junk and all is well.

One way to cope with this is to add a startup sequence to your program that clears the screen, sets the correct font size, turns the brightness up (or backlight on), etc. But in the example above, the unlucky inclusion of a multi-byte instruction would swallow some of your remedial instructions. And there's the (admittedly remote) possibility that the random crud could include an Escape sequence that trashes your startup screen or alters other memorized settings.

None of this means that you should never use the dedicated-serial pin for a display. It's tempting—once development is over, the pin is often unused, and other I/Os may be at a premium. Just keep in mind that weird things can and will happen during downloads.

GLO-series: Turning off the Startup Screen

2011-08-31T08:16:00.000-07:00

Startup screen.

GLO-216 and -416 displays start up with a default screen like the one shown here. The Programmer's Reference describes the ESC X0 instruction, which can be used to store a custom screen. But what if you want a totally blank screen at startup?

The following sequence will configure the GLO to start up blank: 12 27 88 48. That's four bytes consisting of clear-screen (12 decimal, 0x0C hex), escape (27 dec, 0x1B hex), uppercase X (88 dec, 0x58 hex), and the text numeral 0 (zero; 48 dec, 0x30 hex). Send that sequence once, and forevermore the GLO will power up with a blank screen. Well, unless you repeat the ESC X0 process with a non-blank screen.

Since we've been talking about Serial Sender, here's how to send the blank-startup-screen sequence from it: <12,27,88,48>

If you have your startup screen just right and want to prevent it from being changed--even by another ESC X0 instruction--you can write-protect the display by cutting the setup jumper, marked "Dsu" on the interface board. See the Hardware Reference for pix.

Introduction to Serial Sender

2011-08-29T09:07:00.000-07:00

Serial Sender is Seetron's free utility for sending data bytes and strings of text through the serial port of a Windows PC ('95 through Windows 7). It's small (64kB) and simple, requiring no installation. Serial Sender won't replace a terminal program for bidirectional communication, but it's excellent for testing and demonstration of serial displays. This article presents a few screenshots showing how it works.

Radio buttons set the serial data rate (1200-9600bps) and select the comm port number (1-8).That's the extent of the configuration. The program does not mess with the port until you actually press Send, so it generally plays well with other port-aware programs.

To send text out the port, type your message and click Send. To send individual bytes, enclose the decimal value of the byte inside less-than < and greater-than > brackets. For example, the screen below sends a single byte (12 decimal, 0x0C hex, 00001100 binary) followed by the text "Hello World!" (The byte 12 is the clear-screen instruction for most Seetron displays other than BPI- and BPK-.)

The next shot sends the same byte and text, but uses the control-code symbol (ctrl-L) to express ASCII 12. Our docs refer to the control codes by letter and number, so you can use whichever is clearer or easier to remember.

Multiple bytes can be sent in a single set of brackets by separating them with commas. (This example clears the screen with ctrl-L and turns on the backlight with ctrl-N.)

The next example mixes control-code notation with numeric; ctrl-P is the position instruction, the number following is the screen location. Screen locations are expressed by adding 64 to the actual value, so 89 in the example is location 25 on the screen. (The offset of 64 has to do with the way that ASCII character codes are organized; don't worry about it.)

To save the aggravation of adding 64 to express values like screen location, Serial Sender can do it for you--just tack an underscore in front of the number. The last screenshot works the same as the previous one.

In a future blog, we'll cover some more Serial Sender hints and tips.

Port and Power for Serial Displays with a USB Cable

2011-08-16T15:36:00.000-07:00

Say you want to demo or configure one of our serial displays but your PC lacks a COM port—what to do? One answer: get an inexpensive USB/serial-port cable made by FTDI, spend a couple of minutes crimping on a connector, and you've got a snazzy cable that provides serial output and power.

For this demo, we picked up a USB-RS232-WE-1800_5.0 cable from Digikey. There are several products in this series; make sure you get the right one by decoding the part number:

USB-RS232: USB in, RS-232 out
WE-1800: Stripped wire ends, 1.8 meters long
_5.0: 5V power available

The _5.0 version is sometimes out of stock. Don't substitute the _0.0 model (unless you're going to hook up a separate power supply for the display). If you have a GLO-216 or GLO-416 series display that you're using in noninverted-TTL mode (Spol jumper cut), you can substitute a TTL-232R-5V-WE cable. Its output is not RS-232 compatible, but the GLOs can accept it.

With either cable, the prep is the same: Crimp header sockets to the power, ground and TXD wires (red, black and orange, respectively), click 'em into a 5-pin socket housing, and plug onto a display. Plug the USB connector into the PC and let it search for and install drivers. Take note of the COM port number assigned, or look it up in your control panel. You're ready to go. Now you can (for example) use Serial Sender to demo or configure your display.

We tried the FTDI cables with a variety of PCs ranging from XP to Windows 7, and in all cases the install went smoothly without need for manual installation. The Windows found-new-hardware process loaded the FTDI drivers automatically. Only quirk was that under XP the installer ran twice. After the second run, everything worked.

Note regarding USB power: USB offers enough current to drive any of our OLED or LCD products, but is insufficient to drive VFDs. You can still use the cables, but you will need an external source of regulated 5Vdc.

FTDI USB-RS232 cable

Header sockets crimped to

+5 (red), GND (black) and TXD (orange).

Socket housing installed.

Plugged onto a GLO-216 interface.

Receiving a test message from Serial Sender.

Ultrasonic Sensor Demo Drives Seetron Serial OLED

2011-08-16T09:52:00.000-07:00

At electronicsblog.net, author Darius makes good use of a GLO-216G serial display in an ultrasonic rangefinder demo. In the Youtube video below you can see that he's using the display's extra-large number font in simulated 7-segment mode to get maximum size from the displayed numbers.

GLO-216G Serial OLED Featured at The Electronics Hobbyist

2011-08-16T09:03:00.000-07:00

Great getting-acquainted article on the GLO-216G serial display over at The Electronics Hobbyist blog. Sharp, well-thought-out code for Arduino demonstrates large fonts and custom characters.

In addition to the excellent information, the article contains a coupon code good for 20% off the purchase of a GLO-216 serial OLED display.