0018-9162/02/$17.00 © 2002 IEEE January 2002 33

IBM’s Linux Watch: The Challenge ofMiniaturization

this one have been foundational in our vision of acommunications device that would change lives. Fornearly four years, we have seen this vision evolvingas the IBM Linux watch, a complete computer sys-tem that runs Linux, displays X11 graphics, andhas wireless connectivity.

Figure 1 shows two versions of this watch, onewith an organic light-emitting diode (OLED) dis-play and the other with a liquid crystal display(LCD). The watch fits in a case that could pass as aslightly unusual analog timepiece with a somewhatodd shape and an extraordinarily brilliant face.

The watch interface has a touch screen with sym-bols in the four corners signifying correspondingactions. Touching the top left quadrant takes theuser to a start menu; the bottom left is a back but-ton similar to the one found on Web browsers; thetop right is a shortcut to setting alarms; the bottomright is a shortcut to a list of phone numbers. Thedial on the top right lets users navigate betweenapplications.

Although the watch is still considered a researchprototype, we have already run some personalinformation management applications such as cal-endars, address books, to-do lists, and e-mail sum-maries, and we have used it to interact wirelesslywith other computers running specific applications.We have also used the watch to communicate withPCs, personal digital assistants (PDAs), and other

IBM’s wristwatch computer looks like an ordinarywatch but runs Linux, features X11 graphics, andoffers Bluetooth wireless connectivity.

ChandraNarayanaswami,NoboruKamijoh, MandayamRaghunath,Tadanobu Inoue,Thomas Cipolla,Jim Sanford, andEugene SchligIBM Research

SreekrishnanVenkiteswaran,Dinakar Guniguntala,and VishalKulkarniIBM Software Laboratory, India

KazuhikoYamazakiIBM Japan

W E A R A B L E C O M P U T I N G

Abusinessman carrying a garment bag andbriefcase hurries down a Chicago street,looking at his watch. An ordinary event,except that the watch is giving him a traf-fic report instead of the time.

Noting an accident on the main route to the air-port, the watch displays alternative routes, but nonewill get the traveler there in time for his 10:30 a.m.flight. Touching a corner of the watch face, the trav-eler brings up his agenda. A roll of the tiny wheelmoves the “flight home” entry to 11:30 a.m. anddispatches an e-mail to his secretary in St. Louis.

A few blocks later, the watch vibrates, indicatinga new message—e-mail from his son: “Dad, don’tforget my Chicago Cubs cap.” He also has a mes-sage from his secretary, who has gotten him a seaton the 12:20 p.m. flight and bumped his afternoonmeeting with the marketing director to 4:00 p.m.Speaking into the watch, he sends a message to hiswife’s cell phone: “Flight delay. Can’t pick up Robafter baseball.”

At the airport newsstand, the watch vibratesagain, this time with a text message from his wifesaying that their son has a ride home with a friend.He heads for the gate with the Cubs cap in his brief-case, thinking how complicated life would be with-out his watch.

The businessman and his family are neither spiesnor actors, but ordinary people—and scenarios like

34 Computer

wireless-enabled devices, viewing condensed e-mailand receiving pager-like messages. Eventually, userswill be able to access various Internet-based ser-vices, such as information about weather, trafficconditions, the stock market, and sports.

CONCEPT DEFINITIONThe idea for a wristwatch computer evolved from

a study of how wearable computers would affectpeople and from the general desire across IBM tocreate a cutting-edge technology. Everyone agreedthat cell phones and PDAs were useful but too easyto lose or misplace. As groups exchanged ideas andinformation, the idea of a watch computer began togel, and people were getting excited. Many agreedthat this kind of device would be extremely wear-able, likely to be with you, and easy to access.

The idea took off in June 1998, when a teammember created an attention-grabbing graphicalanimation of the smart watch concept and pre-sented it at an in-house conference on pervasivecomputing. People outside our group left thinking,“What if we could really build this?” Seiko’sannouncement in mid-1998 that it was building theRuputer,1 their version of a watch computer,became our line in the sand.

QUESTIONS AND MORE QUESTIONSIn December 1998, IBM Research experts in sys-

tem design, operating systems, computer graphics,displays, batteries, user interfaces, data synchro-nization, and mechanical packaging assembled inHawthorne, New York, for a day-long kickoff meet-ing. The exchange left several people eager to buildthe watch without delay.

Knowing that a “make it and they will come” atti-tude alone wasn’t going to lead to success, we triedto first answer some basic questions: Who were thetarget users? What would they do with the watch?What input devices would we need? Who wouldwrite the software? What other devices would inter-act with the watch? These questions led us to exam-ine relevant technologies—display, CPU, connectionmode, memory, operating system, battery life, anddata storage.

Personal information management, wireless

information retrieval from the Web, and location-based services emerged as the most wanted appli-cations. People called the watch everything from ageneric pager to an information appliance. Itbecame clear that different people wanted differ-ent applications, which meant that we had to makethe watch programmable.

We examined several high-function watches,pagers, PDAs, and cell phones to see what wasalready available. Seiko’s Ruputer, which ran DOS,was one of the most general-purpose watch com-puters. It did a reasonable job, but we felt we couldimprove on its user interface, which consisted ofseveral buttons for navigating the watch’s func-tions, a joystick for input, and a 102 × 64 pixelreflective LCD display. We came away with twoimportant goals: emphasize aesthetics and improveon user interface intuitiveness.

By the end of January 1999, we had completed apreliminary specification describing high-level goals,key research areas, target applications, and userinterface and input device guidelines. We had alsocompleted our survey of currently available high-function watches and pervasive computing devices.

BASIC DESIGN DECISIONSAs Figure 2 shows, we ended up with three

boards—main, communications, and display. TheLCD version has the main board and the commu-nication board; the OLED version has the mainboard and the display board.

On the main board is an ARM processor fromCirrus Logic (EP 7211), which because of its avail-ability in bare die form, took much less space thana standard-package processor. The EP 7211 camewith on-chip ROM for initial boot; an integratedLCD controller; an infrared controller; serial com-munication, sound, and other interfaces; and twoserial ports for connecting to other devices such asPCs and PDAs.

The communications board evolved from ourdecision to include not only infrared but also radiofrequency wireless access. Including infrared accesswas straightforward because the EP 7211 had abuilt-in infrared module. We also wanted radio fre-quency access because it is omnidirectional and

Figure 1. IBM wrist-watch computer with(a) OLED and (b) LCDdisplay. The slightlylarger LCD watchfeatures auxiliarycard housing underthe wheel.

(a) (b)

January 2002 35

could be used for communication without activelyinvolving the user. Because we did not know for cer-tain if the size and power constraints made it feasi-ble to add a Bluetooth radio, we opted to put theBluetooth module on a separate card.

The display board contains the OLED, which wechose over the LCD with little hesitation, aesthet-ics being an important design goal. We had plannedto accommodate the OLED display on the otherside of the main board. Unfortunately, only theprocessor was available in a bare die, and manyparts destined for only one side of the main boardoverflowed to the other side, which meant therewas no room for the OLED chip.

No existing display met our need for low powerconsumption, high pixel density, and controls to tradeoff brightness for power, so we decided to build onejointly with eMagin Corp.2 We wanted the OLEDdisplay to reside on a silicon chip that the processorwould see as static RAM. Every high bit in the staticRAM would then turn on one of the LEDs in thearray. Thus, unlike LCDs, the display would not needrefreshing. The OLED display would not be avail-able until several months after the main board, how-ever, so we decided to use a 96 × 120 pixel reflectiveLCD display in the interim so there would be twoversions—an LCD and an OLED.

Our decision to use a touch screen and rollerwheel as input devices took a little longer. Touchscreen proponents argued that the absence of but-tons made the watch elegant and simplified the userinterface. Those who were opposed argued that thesmudges on touch screens would look awful anddecrease the display’s readability.

We decided that the touch screen should havejust four distinguishing quadrants, correspondingto the display’s four corners. If this proved too lim-iting, we could add a fifth zone at the display’s cen-ter; anything finer would be very hard to use. Tonavigate the applications and data, we added aroller wheel; to experiment with a speech interface,we included a speaker and a microphone.

Once we had the board designs, we began esti-mating power consumption and drain. It soon becameclear that we needed a rechargeable battery to supplythe peak current that the watch would draw.

We had yet to select two major items in the spec-ification: the operating system and graphics library.The choice of operating system led to interestingdiscussions ranging from “Who needs an operat-ing system for a watch?” to “We need to provide anindustrial-strength operating system.”

We looked at several embedded operating sys-tems such as pSOS, vxWorks, EPOC 32, and QNX

and spoke to others who had studied this questionunder different constraints. We soon learned thatit is difficult to license a commercial operating sys-tem for a research project without well-definedproduct plans or volume projections. The devel-opment environments were also rather costly.

Inside IBM, effort was being directed at Linux,which was a good reason to choose it. Another com-pelling reason was cost: The source code and the toolswere free. Moreover, many of us were familiar withrunning Unix on workstations. There was still a ques-tion of whether we could run Linux on a device thissmall, but since others had run Linux on devices withless memory and computational power, we were rea-sonably confident that it would run on the watch.People outside the project shook their heads and toldus we had just sounded its death knell.

About the time we were debating the operatingsystem question, we began to address the issue ofgraphics libraries. Given the small display and thelimited amount of resources available on the watch,having a full-fledged graphics library initiallyseemed like overkill. Nevertheless, we believed thatsupporting a standard, well-understood graphicslibrary would be beneficial because it would helpsimplify application development. Of the availablechoices, X11 was very stable. Though it was large,we knew that it would fit, and we knew that itsdevelopers were working on making it smaller.

Table 1 summarizes the evolution of the hard-ware specifications, which were completed in June1999. The watch would have an ARM EP 7211processor, 8 Mbytes of flash memory, 8 Mbytes ofDRAM, a touch screen, a roller wheel, infrared andBluetooth wireless interfaces, X11 graphics, and aspeaker and microphone. We were ready to startdesigning and building the three boards.

COORDINATING DEVELOPMENTIn parallel with building the boards, we wanted

to study user interface issues and work on the soft-ware libraries and drivers that would help us bringup the hardware. To do this, we needed some pro-

Figure 2. The threeboards designed forthe wristwatch com-puter. The mainboard (left) containsthe processor, thecommunicationsboard (middle)houses the Blue-tooth module, andthe display board(right) contains theorganic LED display.

36 Computer

totyping platforms. The first was an x86-based PCrunning Linux that would let us look at the Linuxsource code and tools. To simulate applications thatwould run on the OLED watch, we used a backlit,color LCD display (27 × 20 mm), which we hadused as part of an earlier project. The display hada 640 × 480 pixel resolution but was slightly larger.It was useful in prototyping different screens todetermine how easy or difficult it was to view themand what was readable on the display. As Figure 3shows, the display had an interface module thatwould send standard monitor output from a lap-top to the LCD display.

To bring up Linux and build some of the devicedrivers, we procured development boards fromCirrus Logic that housed the EP 7211 and directlyattached the reflective LCD displays. We planned tofirst mount the circuit boards for the watch onto10 × 15 cm (4 × 6 inches) test benches, such as theone in Figure 4, to make hardware debugging eas-ier. After some initial hardware testing, we plannedto assemble the boards into watches. The firstwatches would then have the lower-resolutionreflective LCD display.

When the OLED displays were finished, weplanned to put them on the test benches first andthen assemble watches with OLED displays. Wealso planned to build docking stations, or cradles,so that users could charge the watch batteries andeasily transfer data from a PC to the watch. Theplatforms helped ensure that the developers stayed

focused on a common vision, feeding what theylearned into the hardware and software designs.

A team from Tokyo led the hardware design,selected the parts, and built the boards. The sameteam led the industrial design, contributed to themechanical design, ported the Bluetooth protocolstack, and built Bluetooth-related applications. Ateam from Yorktown worked on the software archi-tecture, user interfaces, prototype applications,Linux driver architecture, and overall project man-agement. A second team from Yorktown did themechanical packaging work. Yet another team fromYorktown collaborated with people from IBMZurich and eMagin Corp. to build the OLED dis-play. A team in Bangalore, India, worked with theteam from Yorktown on the Linux drivers, ways toport the X11 library, and the hardware test code.

BOARD DESIGNThe board design was challenging, and a reduc-

tion of even 0.5 mm was considered well worth thework. We needed additional switching voltage reg-ulators for the OLED display, and we had to makesure that the power supply noise would not affectthe Bluetooth module. Because of these constraints,we tried to eliminate all the wires to the touch panel,roller wheel, accessory card, and battery, using elas-tomer connectors and gold-plated spring contactsinstead.

We carefully selected all the board parts anddesigned them to meet these requirements.

Table 1. How the IBM Linux watch specification evolved.

Hardware feature Candidates Final specification Reasons

Processor Motorola’s DragonBall EZ and MPC 823, ARM 7 Required little additional logic; availableStrong ARM, ARM 7Series (Cirrus Logic (Cirrus Logic EP 7211) in bare die form; low power consumption;PS 7111/EP 7211), NEC V4111, offered several power modes; had provenHitachi SH 7709a, VLSI VWS 22100 success in running popular operating

systemsMemory As large as possible 8 Mbytes of flash memory, Compatibility with operating system

8 Mbytes of DRAM footprint, application size, and data storage on ARM architecture; memory configurationof existing devices

Wireless access Infrared, Bluetooth, cellular, Infrared on main card, ARM 7 chip has infrared module; too manymechanisms pager systems Bluetooth on separate card unknowns to put Bluetooth on main card Display Backlit or reflective LCD, organic LED 640 × 480, 741-dpi OLED Easier to read than reflective or backlit LCD;

consumed less power than a backlit LCD Input device Buttons, touch screen, jog dial, Touch screen, jog dial Ease of use, more elegant appearance

rocker, joy stickPower medium Lithium, Zi-Air, and alkaline batteries; solar, Rechargeable, lithium polymer Ability to cope with the watch’s peak

self-winding; thermocouple-based energy batteries current draw; solar and other self-winding methods did not generate sufficient energy

Operating system None; embedded systems: Linux, EPOC32, Linux Availability of source code and tools; workedQNX, vxWorks, DOS on a system with limited memory and

computing power Graphics X11, direct frame buffer access, X11 Most complete, stable, and general library;

Microsoft Windows available with source code

January 2002 37

Figure 3. Backlit LCD display used in application and user interface prototypingfor the watch with the OLED display.

Figure 4. Test bench for hardware debugging. The bench is roughly 4 × 6 inches.

Unfortunately, however, we could not get all theparts as specified, and we ended up with severalmanual wire connections in the LCD watch—aproblem we rectified for the OLED watch by usingan elastomer connector.

We were particularly concerned about the powerconsumed in standby mode. We had to considerfuture functional expansion using auxiliary boardsand how those boards would interface to the mainboard for other types of devices. In light of this, weopted for fine-pitch expansion tabs at the card edgeto support various external expansion interfaces.We used IBM’s surface laminar circuit packagingtechnology to design a multilayer circuit board withextremely fine-pitch connections.

We bonded the bare-die processor chip directlyonto the board and sealed it with epoxy. Using achip-stacked memory module for the flash mem-ory allowed us to accommodate variations in mem-ory size and types in the same board design. To savereal estate, we attached the chip-size packageDRAM to the board in a flip-chip fashion. Many ofthe other components were extremely small, andthe team put them on the main card at IBM’sadvanced packaging facility in Yasu, Japan. Thesmallest chip resistor was 0.3 × 0.6 × 0.3 mm,requiring a microscope and an ultrafine solder ironfor touch up, not to mention excellent fine-motorskills and steady hands.

Since the processor was a bare die, we could nottest it exhaustively before assembly, so we addedan external in-circuit emulator and a diagnosticLED for debugging. We also had to be extremelycareful in verifying the design and assembly becauseerrors could render the entire board unusable.

The expansion board concept was key eventhough the system could consume more power. Webelieved that the benefits of additional functions,radio frequency communications, and sensors werea good tradeoff.

PROTOTYPING EXPERIMENTSAlthough we knew the LCD watch would appear

first, we started with application and user interfacedesign for the VGA resolution OLED display3

because we felt that it afforded a richer set of appli-cations. Initially, we used slide-presentation soft-ware to create screens to study different font typesand font sizes to see what was readable. We alsoexperimented with using slide-show animations todisplay clock faces and other graphical content, butwe very quickly discovered the limits of what youcan do with slide shows. We switched to writingactual code on a Linux system to model user inter-

actions and how the screens would change inresponse. To model the interactions, we simulatedthe touch screen and the roller wheel.

Because we had no touch screen for the display,we used four keys on the laptop’s keyboard to emu-late it. Our roller wheel was similar to that on awheel mouse, so we connected a wheel mouse to thelaptop to emulate the roller wheel. With these inputmechanisms, we prototyped many potential screensand captured the navigation between them. Toenable rapid prototyping and easy code changes, weused T/cl/Tk, a high-level scripting language andgraphics toolkit, to write the code.

We began showing the prototype to people andasking how easy or difficult they found navigationbetween screens. When we showed our demos, thelarge, heavy interface module that connected thebacklit LCD display to the laptop became a sourceof amusement. People often asked if we had tocarry this large box to use the watch, to which wequipped, “No, it contains the watch’s batteries.”

38 Computer

During this time, we had to decide whether toorient the OLED display in landscape or portraitmode. Wristwatches are generally in portrait mode,but we were not sure if we wanted to use this optionfor our watch. To see which was better, we cut arectangle the size of the OLED display from a pieceof paper and placed the cutout on various text andgraphic images in both orientations. When weplaced the rectangle on a phone book to emulatetext in a small font, we preferred the landscape ori-entation because fewer lines with more charactersper line were easier to read than fewer charactersand more lines. For graphic images, the orientationdid not seem to make much difference.

To select the color of the OLED display, we useda 600-dpi printer and printed transparencies usingtext in various colors on a black background. Toget an approximation of what the actual OLEDswould look like, we placed the transparencies ona fluorescent screen and adjusted the color satura-tion to achieve equal brightness. Yellow text wasmore readable than blue or green because of thehigher contrast. This was good news because yel-low OLEDs used a reasonable number of lumensper watt. Green used the fewest lumens, but yel-low was not far behind and was far more readable.

After we built the application prototype for theVGA resolution OLED display, we converted every-thing to fit the 96 × 120 pixel resolution LCD dis-play. Because we had written the code in a high-levelscripting language, conversion was easy, but wefound that we could not perform some functions onthe LCD display. Luckily, the dot pitch on our lap-top LCD displays was comparable with that of ourLCD. In the initial stages, we simply developed theprototype using a 96 × 120 pixel window on the lap-top screen. We then used the actual LCD, first on aCirrus Logic development board and then on the testbench, before finally moving the code to the actualwatch.

We ran the application code on a laptop whileanother program on the laptop periodically tooksnapshots of the window and sent it on a serial lineto the Cirrus Logic development board, as shownin Figure 5. We used the laptop keyboard and thewheel mouse for the interaction. Later, once Linuxand X11 were running on the development boardand the test bench, we ran the code on the watch.

We followed the identical steps for the OLEDdisplay. Having some demonstrable functionalityearly on proved valuable. The demos were excit-ing, and we received valuable input that improvedthe design. The feedback also helped us measureour progress as we moved the code from one pro-totyping platform to the next, getting closer to thefinal hardware.

PACKAGING ISSUESUntil we had put the board, touch screen, and

all the hardware into an actual watch case andattached wrist straps, we did not really have awatch. We explored several packaging options,including simply buying a watch and replacing itsguts with our hardware. We worked on the casefor the LCD watch while the boards were beingbuilt. Regrettably, we could not find a watch thatwas the right size and shape, so we had to cus-tomize the case and build it.

Our industrial designers and mechanical engi-neers used 3D tools to model the placement of com-ponents on the boards and the positioning of theboards inside the case. Because this was a proto-type, we did not devote much attention to manyissues that watch designers worry about, such aswaterproofing and shock resistance.

For connections between the watch and thespring pins on the watch cradle, we used a flexiblecircuit wrapped around the battery, which wouldeasily accommodate a thicker battery if we neededit. After a few iterations, we developed a compactcradle design with a docking mechanism thataccommodates watches with both the LCD andOLED displays. We used optic fibers to route thestatus lights on the circuit board to the top of thecradle and designed a special mechanical assemblyto bring the push buttons on the cradle board tothe top of the cradle.

The watch strap is a custom design so that a usercould more easily manipulate the wheel, but it usesstandard buckles and band holder pins, which wepurchased at a neighborhood watch store. Ourrepeated trips to get buckles and pins (one trip foreach prototype) roused the store owner’s curiosity,and she asked if we were building watches. When

Figure 5. Cirrus Logic development board with liquid crystal display. The LCD wasused first on the development board and then on the test bench before finallymoving the code to the actual watch.

January 2002 39

we showed her the watch and what it could do,she was eager to sell it.

GETTING LINUX TO RUNIn preparation for our most significant step, we

needed to build a cross-development environment,including cross compilers, assemblers, and binaryutilities that would let us generate code for the ARMarchitecture on our x86 desktops. Although therewere many resources on the Internet to help in thisprocess, it took some time to get everything set upright. We also had a fairly steep learning curve.

When we began the project, nobody was run-ning Linux on an EP 7211, but patches were avail-able to run Linux on an earlier generation, theCLPS 711x. After finding relevant pieces of sourcecode and patches on the Internet, we wrote someof the basic device drivers and modified the mem-ory maps for our hardware.

The EP 7211 had a good bootstrap mechanismin which the chip boots from an on-chip bootROM and subsequently loads up the operating sys-tem code over a serial line into DRAM or flashmemory. This bootstrap mechanism made it pos-sible to bring up Linux fairly rapidly. After a fewiterations of debugging both the development envi-ronment and the device drivers, Linux would gothrough the boot sequence and start the kernel, butit would crash the first time a process was forked.By April 2000, we had solved these issues and a“#” prompt from the shell demonstrated thatLinux was running on both the developmentboards and our test bench. To get to this point, wehad to get the kernel running on the watch, as wellas the basic libraries (libc, libm, and libdl), a shell,and some basic commands.

We then began preparing a demo program toshow that we had Linux running on our watch. Wefirst redirected the bootup messages to the LCD.The messages scrolled past quickly because it tookless than 10 seconds for the watch to boot up. Wehad to slow down the boot process to actually seethe messages scrolling up on the LCD. After bootup,we started an endless shell loop that executed basicLinux commands such as echo, ls, and mv. The loopdemo, shown in Figure 6, demonstrated that wecould run Linux and a shell on the watch, but weneeded to do more. We endured many jokes abouthaving to type “date” to get the time.

BRINGING UP X11 GRAPHICSAlthough we had won a major battle in getting

Linux to run, we still needed to get X11 running aswell. Most people thought we were crazy, but our

preliminary calculations showed that early work-stations running X11 had less memory and horse-power than our watch. If X11 could run on thosemachines, it would certainly run on our device. Andwe had good reasons for our choice. X11 works ontop of Linux. Other graphics libraries such asNanoX, MicroWindows, and FLTK were still intheir infancy. We would be leveraging a familiaropen source graphics API on top of an open sourceoperating system. Finally, we could run applicationswritten in scripting languages like T/cl/Tk.

The road to implementation had more than a fewpotholes, however. When the server came up, a sim-ple program would crash the system, which we dis-covered was caused by errors in the display driverand pixel-writing routines. When we had pro-gressed to the stage where a drawn line appeared asseveral disjointed lines, we knew we were close.After ironing out a few more bugs, we were able torun the xclock program. In early July 2000, the pro-totype watch could display the hour and minutehands and keep time, and our colleagues finallystopped asking, “Yes, but does it show the time?”

DEBUT AT LINUXWORLDWe were ready to show our watch at a public

forum, and we knew it was newsworthy. After somediscussion, we decided that the LinuxWorld Expo inmid-August would be the ideal place.

We already had the endless loop of shell com-mands and the clock program, but to prove to skep-tics that Linux was running on the watch, we hadto provide a method for typing in Linux commandsthat the watch could execute and for displayingresults. The cradles arrived just in time for us to setup a demo in which an interactive shell programaccepted commands from the serial interface on thewatch and executed them in response to the user. Aserial cable connecting the cradle to a laptop run-ning a terminal emulator completed the picture.

On 7 August 2000, IBM issued a press release4

stating that we were successfully running Linux ona wristwatch prototype. The Wall Street Journal andIEEE Spectrum, among others, covered the

Figure 6. Linux shellloop demo. Thedemo program exe-cuted basic com-mands to show thatLinux was runningon the watch.

40 Computer

announcement, and the response was over-whelming. The exposure set off discussionsin various online forums, such as Slashdot’s“News for Nerds, Stuff That Matters.”

When we arrived to set up the watches atthe LinuxWorld Expo, our booth was alreadycrowded, and the universal reaction was “waycool.” It was a heady experience. LinusTorvalds showed up and said he would likeone. Jim Gettys, one of X11’s principal

authors, and Eric Raymond, an advocate of the opensource movement, also stopped by. Parents who sawthe watch brought their children in to see it the fol-lowing day. The team from Compaq that had builtItsy5 seemed interested in how we had managed topack so much into something as small as a watch.

FROM LCD TO OLEDShortly after our LinuxWorld debut, the first

OLED displays became available, and they weremore impressive than we had imagined. Relativeto the backlit LCDs we had used for software pro-totyping, the OLED display seemed positively daz-zling.

Building the OLED displays had been complex.Our fabricators had first built silicon circuits on thewafers and then deposited multiple layers oforganic materials on top. In the first set of displays,the fabricators had discovered the need to seal thechip to keep the organic materials from deteriorat-ing. They had also encountered various depositionand packaging issues.

The OLED and LCD designs were different,6 butwe still got the OLED displays to work on the firstpass. To verify that it was up and running, we hadthe OLED display show different patterns. Insteadof building custom test circuitry to show the pat-terns, we used a video card with digital output. Thevideo card scanned the contents of its video RAMand output one word at a time. By creating differ-ent sequences of 1s and 0s in the video RAM, wegenerated digital waveforms of different shapes andtiming patterns. We used this technique to gener-ate the appropriate addresses, read and write cycletimings for the OLED chip, and image data. Inaddition to encoding many images to determine dis-play quality, we used images from the applicationprototyping to see how they would look on thewatch.

Connecting the OLED display to the main cardwas not easy because it involved making about 50connections at a fine pitch. We used an elastomerconnector, but it was difficult to make this connec-tion reliable. Finally, we changed the elastomer and

increased the compression to ensure proper contact.Our last challenge was to bring up Linux and

X11 on the OLED watch, and we ran into anotherinteresting problem. The OLED had a 16-bit-widedata bus and expected short word stores to writedata into it. When we built the X11 server code,we had not specified the options that told the com-piler it was okay to generate short word stores. Asa result, the compiler converted each short wordstore into two-byte stores, resulting in a garbleddisplay. We kept staring at the source code andfound nothing wrong. When we finally decided tolook at the object code, it became obvious that weneeded to specify the compiler options.

ADDING BLUETOOTH CONNECTIVITYAbout the same time we were working on inter-

facing the OLED display to the main board, wewere tackling another major development step:adding Bluetooth connectivity to the LCD watch.Again, we benefited from our decision to use Linux.A sister group at IBM Watson Research had alreadywritten the Bluetooth protocol stack and drivers forLinux for an Intel processor. We partially modifiedtheir code, which they called BlueDrekar, andfought some gcc compiler idiosyncrasies to make itwork on the ARM processor. Overall, however, thetask was simpler than writing the code from scratch.

In December 2000, we demonstrated theBluetooth-enabled watch with the LCD display atthe Bluetooth Developers Conference in San Jose,using it to advance the foils for a keynote presenta-tion to about 3,000 people.

Because the human body easily absorbs andaffects the 2.4-GHz wave, we were careful aboutlocating the antenna. We succeeded in impressingthe keynote attendees, who were surprised by thewatch’s communication range.

W e are confident that it is possible to build ahighly functional and elegant wristwatchcomputer. Although we are not there yet,

we are several steps closer than when our visionbegan. Our current focus is on software compo-nents, power management issues,7 and other wayspeople can use the watch.8 For example, they mayprefer using it to display data from their otherdevices, even though they are carrying them. It iseasier to see an agenda or a map on your wrist thanit is to fish around in a briefcase or purse for yourPDA. We are also prototyping services tailored tothe user’s current location and context and lookinginto services that leverage connectivity to theInternet.

Adding Bluetoothconnectivity to the LCD watch was a major

development step.

January 2002 41

Another important step is the research collabo-ration of IBM Research and Citizen Watch,announced in October 2001,9 to further explorethe possibility of bringing the watch to a wideraudience, conducting pilot tests, and pursuing col-laborative research with universities. Updates onour progress are available at http://www.research.ibm.com/WearableComputing.

Our work has convinced us that a lot of function-ality can be squeezed into small devices. The avail-ability of the source code, the APIs, the reliability ofthe software, and the enthusiasm of the Linux com-munity are paving the way for Linux to become anattractive operating system for such devices. Asresearchers combine high-function miniature hard-ware with a robust operating system and well-designed applications with intuitive user interfaces,we will see more science fiction gadgetry becomeeveryday tools that people take for granted. �

AcknowledgmentsNumerous people have contributed to the success

of this project. We have received much encourage-ment and enthusiastic support from our manage-ment. Several others have given us usefulsuggestions and provided valuable technical input.We thank the following individuals and apologize toanyone we might have inadvertently omitted:Rachel Bellamy, Tilman Beierlein, Tom Corbi, SteveDepp, Murthy Devarakonda, Derek Dove, AmbujGoyal, Paul Greier, Erik Harris, Randall Isaac,Michael Karasick, John Karidis, KohichirohKishimoto, Jayadevan Kumanan, Kartik Kumar,Akihiko Mizutani, Robert Morris, Alex Morrow,Michael Olsen, Bob Olyha, Carl Powell, WalterReiss, Heike Riel, Tiaa Sahni, Omesh Sahni, AlfredSpector, Sunil Sreenivasan, Vijay Sukthankar, andKen Tamagawa.

References 1. “Ruputer the Wrist Computer,” http://janus.free.fr/

ruputee.html (current Dec. 2001).2. eMagin, “eMagin and IBM to Demonstrate New

OLED Display at the Consumer Electronics Show,”5 Jan. 2001, http://www.emagin.com/pressreleases/pribmwatch.htm (current Dec. 2001).

3. C. Narayanaswami and M.T. Raghunath, “Applica-tion Design for a Smart Watch with a High Resolu-tion Display,” Proc. 4th IEEE Int’l Symp. WearableComputers, IEEE CS Press, Los Alamitos, Calif.,2000, pp. 7-14.

4. IBM Research, “Linux on a Wristwatch,” Aug. 2000,

http://www.research.ibm.com/WearableComputing/factsheet.html (current Dec. 2001).

5. W.R. Hamburgen et al., “Itsy: Stretching the Boundsof Mobile Computing,” Computer, Apr. 2001, pp.28-36.

6. J. Sanford and E. Schlig, “Direct View Active MatrixVGA OLED-on-Silicon Display,” Int’l Symp. Soc. forInformation Display, Digest of Technical Papers, vol.32, 2001, pp. 376-379.

7. N. Kamijoh et al., “Energy Trade-offs in the IBMWristwatch Computer,” Proc. 5th Int’l Symp. Wear-able Computers, IEEE CS Press, Los Alamitos, Calif.,2001, pp. 133-140.

8. C. Narayanaswami et al., “What Would You Do witha Hundred MIPS on Your Wrist?” tech. report RC22057, IBM Research, Yorktown Heights, N.Y., May2001.

9. IBM Research News, “Citizen Watch and IBMResearch Announce Research Collaboration onLinux Watch Technology,” http://www.research.ibm.com/resources/news/20011011_watchpad.shtml(current Dec. 2001).

Chandra Narayanaswami is a manager of thewearable computing department at IBM T.J. Wat-son Research Center, where he is the overall pro-ject leader and an architect for the Linux watch.Noboru Kamijoh, a senior researcher at the IBMTokyo Research Lab, is the watch’s lead hardwarearchitect and hardware designer. MandayamRaghunath is a researcher at Watson and was incharge of the system software and applicationdesign. Tadanobu Inoue is a researcher in Tokyoand worked on the design and verification of thehardware. Thomas Cipolla is a senior engineer atWatson and was in charge of the watch’s mechan-ical packaging. Jim Sanford is a senior engineer atWatson and one of the OLED display designers.Eugene Schlig (deceased) was a research staff mem-ber at Watson and another OLED display designer.

At IBM Software Laboratory, India, SreekrishnanVenkiteswaran, a software engineer, helped bringup Linux. Dinakar Guniguntala, a software engi-neer, helped bring up Linux and X11 for the OLEDwatch. Vishal Kulkarni, a software engineer, helpedbring up X11 for the LCD watch. All three builtdevice drivers.

At IBM Japan, Kazuhiko Yamazaki, a senior tech-nical staff member, was in charge of the watch’sindustrial design.

Contact the authors at chandras@us.ibm.com.