XC-1 Tutorial (Japanese)

XC-1 Development Board Tutorial
Version 10.4
An interactive version of this tutorial is available in the XMOS
Development Environment. To open, choose Help · Welcome
and select the XC-1 tutorial.
Publication Date: 2010/03/16
Copyright © 2010 XMOS Ltd. All Rights Reserved.
XC-1 Development Board Tutorial (10.4)
2/17
1
Introduction
The XC-1 is a development board based on the XMOS XS1-G4 device. It comprises a
single XS1-G4, 16 LEDs, four press-buttons, a speaker, JTAG and serial interfaces,
and a through-hole prototyping area for connecting external components.
The XS1-G4 consists of four XCores, each comprising an event-driven processor with
tightly integrated general purpose I/O. Each processor provides up to eight threads,
400 MIPS and 64 KBytes of RAM. The I/O pins are connected to board components
and can be directly controlled by software (see Section 10).
Programs are written using a combination of XC, C and C++. XC provides extensions
to C that simplify the control over concurrency, I/O and time. These extensions
map directly onto XCore hardware resources such as threads and ports, and are
efficient--compiling into short instruction sequences, and safe--free from many
sources of deadlock, race conditions and memory violations. This makes programs
easy to write, understand and debug.
This tutorial provides an introduction to writing XC programs using the components
integrated on your XC-1. It assumes that you are familiar with C [1]. This tutorial
shows you how to:
· illuminate the LEDs on the board
· flash an LED at a fixed rate
· send the message "Hello World" to your PC over a serial link
· flash an LED while cycling it around the 12-LED clockface
· create concurrent threads that flash LEDs and respond to button presses
· implement a loopback connection using the through-hole area
The example programs show you how XC simplifies the creation of programs for
event-driven processors. Sections of the tutorial that introduce a new language
feature include the new keywords or operators in their title.
The example programs have been tested with version 10.4 of the tools. Information
on downloading, installing and using these tools is provided in a separate user
guide [2].
2
Illuminate an LED: port, <:
This part of the tutorial shows you how to illuminate an LED on your XC-1, using an
XC port and output statement.
www.xmos.com
XC-1 Development Board Tutorial (10.4)
3/17
The XC-1 has 16 LEDs. Four of these LEDs are positioned next to the four press-
buttons (collectively referred to as button-LEDs) and contain green diodes. The other
12 LEDs are positioned around the XS1-G4 in a circle (collectively referred to as
clock-LEDs) and contain both green and red diodes. A Roman numeral is printed
next to each clock-LED.
The XS1-G4 has a number of ports, which are connected to the physical pins and
used to interface with board components. The port logic can drive its pins high or
low, or it can sample the value on its pins.
The program below illuminates a single LED on your XC-1:
# i n c l u d e < p l a t f o r m . h >
out p o r t b l ed = P O R T _ B U T T O N L E D ;
int m a i n () {
b l e d <: 0 b 0 0 0 1 ;
w h i l e (1)
;
r e t u r n 0;
}
The declaration
out p o r t b l ed = P O R T _ B U T T O N L E D ;
declares an output port named bled, which refers to the 4-bit port identifier PORT_BUT-
TONLED (see Section 10). This identifier is defined in the board description file
"XC-1.xn" and is exported to the header file platform.h during compilation.
Integrated input and output statements make it easy to express I/O operations on
ports. In main, the statement
b l e d <: 0 b 0 0 0 1 ;
outputs the value 0b0001 to the port bled, causing the port to drive one of its four
pins high. This in turn causes the LED connected to the pin to illuminate.
The port continues to drive the pins until instructed otherwise or until the program
terminates. The infinite loop that follows the output statement prevents the latter
condition.
Compile and run this program on your XC-1. The LED labeled A should illuminate.

Modify the value output to the port so that all four button-LEDs are illuminated.

The schematic for the 12 clock-LEDs is shown below; the location of the ports are
shown in the diagram on page 15.
www.xmos.com
XC-1 Development Board Tutorial (10.4)
4/17
I
II
III
IIII
V
VI
VII
VIII
IX
X
XI
XII
[1]
[2]
[3]
[0]
[1]
[2]
[3]
[0]
[1]
[2]
[3]
[0]
PORT_CLOCKLED_2
PORT_CLOCKLED_0
PORT_CLOCKLED_1
PORT_CLOCKLED_SELG
PORT_CLOCKLED_SELR
The anodes are connected to three 4-bit ports: PORT_CLOCKLED_0, PORT_CLOCKLED_1
and PORT_CLOCKLED_3. The cathodes are connected to two 1-bit ports: PORT_CLOCK-
LED_SELG (green) and PORT_CLOCKLED_SELR (red). This means that two pins must be
driven to illuminate a clock-LED.
The program below illuminates the red diode of an LED connected to
PORT_CLOCKLED_0:
# i n c l u d e < p l a t f o r m . h >
out p o r t c l e d 0 = P O R T _ C L O C K L E D _ 0 ;
out p o r t c l e d G = P O R T _ C L O C K L E D _ S E L G ;
out p o r t c l e d R = P O R T _ C L O C K L E D _ S E L R ;
int m a i n ( v o i d ) {
c l e d G <: 0;
// d i s a b l e G R E E N l i n e
c l e d R <: 1;
// e n a b l e RED l i n e
c l e d 0 <: 0 x1 ; // LED p a t t e r n
w h i l e ( 1 ) ;
r e t u r n 0;
}
PORT_CLOCKLED_SELG is driven low, PORT_CLOCKLED_SELR is driven high and the value
0x1 is output to PORT_CLOCKLED_0 (IIII, V, VI, VII).
Compile and run this program on your XC-1. The clock-LED numbered VII should
illuminate red.
Modify this program to illuminate the green diodes of all 12 LEDs.

www.xmos.com
XC-1 Development Board Tutorial (10.4)
5/17
3
Flash an LED: timer, :>
This part of the tutorial shows you how to flash an LED green-red at a fixed rate,
using an XC timer and an input statement.
A timer is a hardware resource used to determine when an event happens or to
delay execution until a particular time. Each timer contains a 32-bit counter that is
incremented at 100MHz and whose value can be input at any time.
The program below flashes an LED green-red on your XC-1.
# i n c l u d e < p l a t f o r m . h >
# d e f i n e F L A S H _ P E R I O D 2 0 0 0 0 0 0 0
out p o r t c l e d 0 = P O R T _ C L O C K L E D _ 0 ;
out p o r t c l e d G = P O R T _ C L O C K L E D _ S E L G ;
out p o r t c l e d R = P O R T _ C L O C K L E D _ S E L R ;
int m a i n ( v o i d ) {
t i m e r tmr ;
u n s i g n e d l e d G r e e n = 1;
u n s i g n e d t ;
tmr : > t ;
w h i l e (1) {
c l e d G <:
l e d G r e e n ;
c l e d R <: ! l e d G r e e n ;
c l e d 0 <: 0 x1 ;
t += F L A S H _ P E R I O D ;
tmr w h e n t i m e r a f t e r ( t ) : > v oi d ;
l e d G r e e n = ! l e d G r e e n ;
}
r e t u r n 0;
}
The statement
tmr : > t ;
inputs the value of the timer tmr's counter into the variable t. Having recorded the
current time, the statement
t += F L A S H _ P E R I O D ;
increments this value by the required delay, and the statement
tmr w h e n t i m e r a f t e r ( t ) : > v oi d ;
www.xmos.com
XC-1 Development Board Tutorial (10.4)
6/17
delays inputting a value until the specified time is reached. The processor must
complete an input operation once a condition is met, even if the input value is not
required. This is expressed in XC as an input to void.
Compile and run this program on your XC-1. A single clock-LED should flash green-
red at the rate defined by the flash period.
Modify this program by reducing the timer period to color-blend the lights and
create the appearence of a constant orange illumination. Note that the red LED
is approximately five times as bright as the green LED, which means it should be
illuminated five times less frequently to create the desired effect.
4
Interface with a host over a serial link
This part of the tutorial shows you how to implement a UART protocol that transmits
a message from the XS1-G4 to your PC over a serial link.
A UART translates data between parallel and serial forms for transmission over a
serial link. Each bit of data is driven for a fixed period, during which time the receiver
must sample the data. The diagram below shows the transmission of a single byte of
data at a rate of 115200 bits/s:
8.68µs
8.68µs
8.68µs
8.68µs
8.68µs
8.68µs
8.68µs
8.68µs
8.68µs
8.68µs
TXD
B0
B1
B2
B3
B4
B5
B6
B7
start
stop
bit
bit
The quiescent state of the link is high. A byte is sent by first driving a start bit (0),
followed by the data bits and then a stop bit (1). A rate of 115200 bits/s means that
each bit is driven for
1
= 8.68µs.
115200
www.xmos.com
XC-1 Development Board Tutorial (10.4)
7/17
The program below serializes a byte of data and transmits its individual bits over a
1-bit port using the UART transmission protocol:
# i n c l u d e < p l a t f o r m . h >
# d e f i n e B I T _ R A T E 1 1 5 2 0 0
# d e f i n e B I T _ T I M E X S 1 _ T I M E R _ H Z / B I T _ R A T E
v o i d t x B y t e ( out p o r t TXD , int b y t e ) {
u n s i g n e d t i m e ;
t i m e r t ;
/* i n p u t i n i t i a l t i m e */
t : > t i m e ;
/* o u t p u t s t a r t bit */
TXD <: 0;
t i m e += B I T _ T I M E ;
t w h e n t i m e r a f t e r ( t i m e ) : > v o i d ;
/* o u t p u t d a t a b i t s */
for ( int i =0; i <8; i ++) {
TXD <: > > b y t e ;
t i m e += B I T _ T I M E ;
t w h e n t i m e r a f t e r ( t i m e ) : > v o i d ;
}
/* o u t p u t s t o p bit */
TXD <: 1;
t i m e += B I T _ T I M E ;
t w h e n t i m e r a f t e r ( t i m e ) : > v o i d ;
}
The function txByte outputs a byte by first outputting a start bit, following by a
conditional input on a timer that waits for the bit time to elapse; the data bits and
stop bit are output in the same way.
The output statement in the for loop
TXD <: > > b y t e ;
includes the modifier >>, which right-shifts the value of byte by the port width (1 bit)
after outputting the least significant port-width bits. This operation is performed in
the same instruction as the output, making it more efficient than shifting the value
as a separate operation afterwards.
www.xmos.com
XC-1 Development Board Tutorial (10.4)
8/17
The XC-1 has a chip that performs a USB-to-serial conversion. When the board is
connected to a PC using a USB cable, this chip presents a virtual COM port that can
be interfaced using a terminal emulator. 1
Load a terminal emulator program on your PC and connect it to the virtual COM
port provided by the XC-1. A simple terminal emulator is available from the XMOS
community website.2
Complete the program above by declaring a port for the UART and by writing a main
function that outputs the message "Hello World!" to this port. You can find the
relevant port in the diagram at the end of this tutorial on page 15. Compile and run
this program on your XC-1. The terminal should receive and display the message.
5
Flash and cycle LEDs at different rates: select
This part of the tutorial shows you how to flash an LED while cycling it around the
LED clockface on your XC-1, using the XC select statement.
The select statement is used to respond to one of a set of inputs, depending on
which becomes ready first. If more than one input becomes ready at the same time,
only one is executed.
The select statement below waits for one of two timeouts to occur and then responds
to this timeout:
s e l e c t {
c a s e t m r F w h e n t i m e r a f t e r ( t i m e F ) : > v o i d :
/* r e s p o n d to timeout ,
* s w i t c h LED b e t w e e n on and off */
...
b r e a k ;
c a s e t m r C w h e n t i m e r a f t e r ( t i m e C ) : > v o i d :
/* r e s p o n d to timeout ,
* c h a n g e w h i c h LED is f l a s h i n g */
...
b r e a k ;
}
1Currently on MACs, the virtual COM port cannot be supported at the same time as the JTAG
interface, preventing you from completing the following exercise.
2http://www.xmoslinkers.org/tag_search?tag=uart
www.xmos.com
XC-1 Development Board Tutorial (10.4)
9/17
The program below uses this select statement to update the state of the LED flash
and cycle algorithms at different rates:
# i n c l u d e < p l a t f o r m . h >
# d e f i n e F L A S H _ P E R I O D 1 0 0 0 0 0 0 0
# d e f i n e C Y C L E _ P E R I O D 6 0 0 0 0 0 0 0
out p o r t c l e d 0 = P O R T _ C L O C K L E D _ 0 ;
out p o r t c l e d 1 = P O R T _ C L O C K L E D _ 1 ;
out p o r t c l e d 2 = P O R T _ C L O C K L E D _ 2 ;
out p o r t c l e d G = P O R T _ C L O C K L E D _ S E L G ;
out p o r t c l e d R = P O R T _ C L O C K L E D _ S E L R ;
int m a i n ( v o i d ) {
u n s i g n e d l e d O n = 1;
u n s i g n e d l e d V a l = 1;
t i m e r tmrF , t m r C ;
u n s i g n e d timeF , t i m e C ;
t m r F : > t i m e F ;
t m r C : > t i m e C ;
w h i l e (1) {
s e l e c t {
c a s e t m r F w h e n t i m e r a f t e r ( t i m e F ) : > v o i d :
l e d O n = ! l e d O n ;
c l e d G <: l e d O n ;
t i m e F += F L A S H _ P E R I O D ;
b r e a k ;
c a s e t m r C w h e n t i m e r a f t e r ( t i m e C ) : > v o i d :
c l e d 0 <: l e d V a l ;
c l e d 1 <: ( l e d V a l > > 4);
c l e d 2 <: ( l e d V a l > > 8);
l e d V a l < <= 1;
if ( l e d V a l == 0 x 1 0 0 0 )
l e d V a l = 1;
t i m e C += C Y C L E _ P E R I O D ;
b r e a k ;
}
}
r e t u r n 0;
}
Compile and run this program on your XC-1. A flashing LED should cycle clockwise
around the clockface.
www.xmos.com
XC-1 Development Board Tutorial (10.4)
10/17
6
Respond to a button concurrently: par
This part of the tutorial shows you how to perform multiple tasks concurrently, using
the XC par statement.
The par statement provides a simple way to create concurrent threads that run
independently of one another. The program below creates two concurrent threads,
one which runs an instance of the function cycleLED, the other an instance of the
function buttonListener:
in
p or t b u t t o n s = P O R T _ B U T T O N ;
out p o r t s p e a k e r = P O R T _ S P E A K E R ;
int m a i n ( v o i d ) {
par {
c y c l e L E D ( cled0 , cled1 , cled2 ,
cledG , cledR ,
F L A S H _ P E R I O D , C Y C L E _ P E R I O D );
b u t t o n L i s t e n e r ( buttons , s p e a k e r );
}
r e t u r n 0;
}
The function cycleLED cycles a flashing LED around the clockface (see Section 5).
The function buttonListener, defined below, waits for input from a button and then
outputs a tone to the speaker:
# d e f i n e T D E L A Y
1 0 0 0 0 0
# d e f i n e T L E N G T H 500
v o i d b u t t o n L i s t e n e r ( in p o r t b , out p o r t s p k r ) {
t i m e r tmr ;
int t , i s O n = 1;
w h i l e (1) {
b w h e n p i n s n e q (0 xf ) : > v o i d ;
tmr : > t ;
for ( int i =0; i < T L E N G T H ; i ++) {
i s O n = ! i s O n ;
t += T D E L A Y ;
tmr w h e n t i m e r a f t e r ( t ) : > v oi d ;
s p k r <: i s O n ;
}
}
}
The pinsneq function causes the input to wait until the value sampled on the pins is
not equal to the bit pattern 0xf, which signifies that one or more of the four buttons
was pressed. The for loop sends a sequence of alternating ones and zeros to the
www.xmos.com
XC-1 Development Board Tutorial (10.4)
11/17
speaker at the frequency specified by the delay, for the specified period of time. This
causes the speaker to emit an audible tone.
Modify the example in Section 5 so that the code for cycling a flashing LED around
the clockface is implemented as the body of the function cycleLED. Compile and
run this complete program on your XC-1. A flashing LED should cycle around the
clockface; pressing any of the four buttons at any time should result in an audible
tone.
Extend the buttonListener function with four additional tone parameters, so that
pressing different buttons results in different tones being emitted.
7
Use a button to change the LED color: chan, chanend
This section of the tutorial shows you how to use an XC channel to communicate
between threads, so that pressing a button in one thread causes another thread to
change the color of a flashing LED.
An XC channel provides a synchronous, bidirectional link between two threads. A
channel is declared using the chan keyword, as in the program below:
int m a i n ( v o i d ) {
c h a n c ;
par {
c y c l e L E D ( cled0 , cled1 , cled2 ,
cledG , cledR ,
F L A S H _ P E R I O D , C Y C L E _ P E R I O D ,
c );
b u t t o n L i s t e n e r ( buttons , speaker , c );
}
r e t u r n 0;
}
A channel consists of two channel ends, which two threads can use to interact
on demand using the XC input and output statements. The XC input and output
operators can be used for channels, as in:
c <: 0;
This statement outputs the value 0 to the channel c. As the channel is synchronous,
the output operation waits until a matching input operation is ready before continuing.
Similarly, an input operation waits for a matching output operation before continuing.
A channel end may be explicitly referred to as a function parameter using the chanend
keyword, as in the declaration below:
v o i d b u t t o n L i s t e n e r ( in p o r t b , out p o r t spkr , c h a n e n d c );
www.xmos.com
XC-1 Development Board Tutorial (10.4)
12/17
Modify the buttonListener function so that immediately after inputting from the
button, the value 0 is output to c.
Modify the cycleLED function so that it takes an additional channel end argument
and declares a local variable isGreen. Modify the select statement to accept an
input from this channel; when selected the color is changed as follows:
c a s e c : > int :
i s G r e e n = ! i s G r e e n ;
b r e a k ;
Finally, modify the flash timeout body so that it illuminates either the green or red
LED, depending on the value of isGreen. Compile and run this program on your XC-1.
Pressing a button should change the color of the flashing LED as well as producing
an audible tone.
Note that you cannot output to a port in two concurrent threads, nor can you write
the same variable in parallel. These restrictions prevent common programming
errors such as race conditions, and ensure that the two threads can be run on any
two cores, regardless of whether they share memory.
8
Interface with the prototyping area: on
This part of the tutorial shows you how to use the XC on statement to implement a
multicore program. In this case, a UART transmit and receive protocol is implemented
on XCore 2 (X2) over a loopback connection made between two pins on the through-
hole prototyping area connected to X2.
The multicore program consists of four threads, as shown in the diagram below.
CORE 0
CORE 2
Button
UART
Listener
Channel c
Transmit
Speaker
Channel d
UART
Listener
Receive
The first thread is a button listener, which must be placed on core 0 to interface
with the button pins (X0/PORT_BUTTON). This thread outputs the values received on
www.xmos.com
XC-1 Development Board Tutorial (10.4)
13/17
these pins to a channel connected to a UART transmit thread running on core 2. The
UART transmit thread inputs button press values and then outputs these values to a
jumper pin on the prototyping area (X2/1A).
The third thread is the UART receiver, placed on core 2, that waits for button values
to be received on a jumper pin (X2/1B). The UART receiver outputs these values to
a channel connected to a speaker listener thread running on core 0. The speaker
listener thread inputs button values and then outputs corresponding tones to the
speaker.
To complete the exercises in this section you need to solder a jumper connector
through two holes on the XC-1, as shown below:
1B
1A
X2PortA
The program below uses the on keyword to specify the location of the port declara-
tions and threads:
# i n c l u d e < p l a t f o r m . h >
on s t d c o r e [0] : in
p o r t b u t t o n s = P O R T _ B U T T O N ;
on s t d c o r e [0] : out p or t s p e a k e r = P O R T _ S P E A K E R ;
on s t d c o r e [2] : in
p o r t u a r t I n
= X S 1 _ P O R T _ 1 A ;
on s t d c o r e [2] : out p or t u a r t O u t = X S 1 _ P O R T _ 1 B ;
int m a i n ( v o i d ) {
c h a n c , d ;
par {
on s t d c o r e [0] : b u t t o n L i s t e n e r ( buttons , c );
on s t d c o r e [2] : t r a n s m i t ( uartOut , c );
on s t d c o r e [2] : r e c e i v e ( uartIn , d );
on s t d c o r e [0] : s p e a k e r L i s t e n e r ( d , s p e a k e r );
}
r e t u r n 0;
}
The header file platform.h provides a declaration of the global variable stdcore for
the target device, in this case an XS1-G4.
www.xmos.com
XC-1 Development Board Tutorial (10.4)
14/17
When main is used with on it may contain only channel declarations, a single par
statement and an optional return statement.
Modify the buttonListener function from Section 7 so that it outputs a tone value
to a channel when a button is pressed. (Note: Do not send the delay value directly
since this value is larger than a byte.)
Implement a transmit function that waits for inputs from a channel and sends them
over a serial link using the transmitByte function from Section 4.
Implement a receive function that receives values from a serial link and outputs
them to a channel. This requires implementing a receiveByte function. (Note: Using
the input-shift-right operator :> >> to input a byte into an int results in the byte
being input to the most significant bits of the int. The input value must therefore
be right-shifted by 24 bits after it is received.)
Implement a speakerListener function that waits for inputs from a channel and then,
based on the tone value received, outputs a corresponding tone to the speaker.
Compile and run this program on your XC-1. Pressing any of the four buttons at any
time should result in an audible tone. If the jumper is removed, pressing a button
should not produce a sound.
If you have two XC-1s, connect a wire between two pins, one on each XC-1. Implement
two XC programs, one comprising a button listener and UART transmitter, the other
comprising a UART receiver and speaker listener. Compile and run each of these
programs, one on each board. Pressing any of the four buttons on one board should
result in an audible tone from the speaker on the other.
www.xmos.com
XC-1 Development Board Tutorial (10.4)
15/17
9
What to read next
This tutorial provides only a basic introduction to the XC language and XMOS archi-
tecture. The following documents provide more information on designing with XC
on your XC-1 board:
· Programming XC on XMOS Devices [3]: Provides an in-depth tutorial on how
to write XC programs, including case studies of real-world designs, along with
the official XC language specification and details of its implementation on XS1
devices.
· The XMOS Tools User Guide [2]: Explains how to use the XMOS tools.
· XC-1 Hardware Manual [4]: Provides a functional description of the XC-1
board including the port-to-pin mappings of the through-hole prototyping
areas, required to add additional components to your XC-1 based designs.
You may also find information from the following online resources useful:
· http://www.xmos.com/
· http://www.xcore.com/
10
XC-1 port-to-component map
The diagram below shows how components on your XC-1 are connected to the
processors on the XS1-G4, and gives the port names used in software.
www.xmos.com
XC-1 Development Board Tutorial (10.4)
16/17
XCORE2
X2PortA Header
X2PortB Header
X2D0
X2D1
X2D12
X2D13
X2D2
X2D3
X2D14
X2D15
X2D4
X2D5
X2D16
X2D17
3V3
GND
3V3
GND
X2D6
X2D7
X2D18
X2D19
X2D8
X2D9
X2D20
X2D21
X2D10
X2D11
X2D22
X2D23
XCORE0 PORT_BUTTONLED [A:D]
5V
GND
5V
GND
X2D[0:11]
X2D[12:23]
PORT_BUTTON [A:D]
XCORE0
PORT_CLOCKLED_0/1/2
X0D0
X010
X0D10
X0D11
XOD26
X0D27
PORT_SPEAKER
X0D28
PORT_UART_RX
X0D29
XS1-G4
X0D30
EE2
PORT_UART_TX
X0D31
X0D32
X0D33
X0D36
X0D37
mUSB-B
FTDI
X0D38
X0D39
DEBUG
PROTOTYPE AREA
JTAG
RST
RESET
PGOOD
CLOCK
X2D[24:35]
X2D[36:43]
PWREN#
XCORE2
3V3
PSU
20MHz
XTO
1V
X2D24
X2D25
X2D36
X2D37
X2D26
X2D27
X2D38
X2D39
5V
X2D28
X2D29
X2D40
X2D41
3V3
GND
3V3
GND
X2D30
X2D31
X2D42
X2D43
X2D32
X2D33
NC
NC
X2D34
X2D35
NC
NC
5V
GND
5V
X2PortC Header
X2PortD Header
www.xmos.com
XC-1 Development Board Tutorial (10.4)
17/17
Bibliography
[1] Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language. Prentice
Hall Press, Upper Saddle River, NJ, USA, 1988.
[2] Douglas Watt and Huw Geddes. The XMOS Tools User Guide. XMOS Limited, 2009.
http://www.xmos.com/published/xtools_en.
[3] Douglas Watt. Programming XC on XMOS Devices. XMOS Limited, Sep 2009.
http://www.xmos.com/published/xc_en.
[4] XMOS Limited. XC-1 Hardware Manual. Website, 2009. http://www.xmos.com/
published/xc1hw.
Disclaimer
XMOS Ltd. is the owner or licensee of this design, code, or Information (collectively,
the "Information") and is providing it to you "AS IS" with no warranty of any kind,
express or implied and shall have no liability in relation to its use. XMOS Ltd. makes
no representation that the Information, or any particular implementation thereof, is
or will be free from any claims of infringement and again, shall have no liability in
relation to any such claims.
Copyright ©2009-10 XMOS Ltd. All Rights Reserved. XMOS and the XMOS logo
are registered trademarks of XMOS Ltd in the United Kingdom and other countries,
and may not be used without written permission. Company and product names
mentioned in this document are the trademarks or registered trademarks of their
respective owners. Where those designations appear in this document, and XMOS
was aware of a trademark claim, the designations have been printed with initial
capital letters or in all capitals.
www.xmos.com
Document Outline

• Introduction
• Illuminate an LED: port, <:
• Flash an LED: timer, :>
• Interface with a host over a serial link
• Flash and cycle LEDs at different rates: select
• Respond to a button concurrently: par
• Use a button to change the LED color: chan, chanend
• Interface with the prototyping area: on
• W