1
Joystick API Documentation -*-Text-*-
3
Ragnar Hojland Espinosa
8
$Id: joystick-api.txt,v 1.2 2001/05/08 21:21:23 vojtech Exp $
13
Open the joystick device following the usual semantics (that is, with open).
14
Since the driver now reports events instead of polling for changes,
15
immediately after the open it will issue a series of synthetic events
16
(JS_EVENT_INIT) that you can read to check the initial state of the
19
By default, the device is opened in blocking mode.
21
int fd = open ("/dev/js0", O_RDONLY);
28
read (fd, &e, sizeof(struct js_event));
30
where js_event is defined as
33
__u32 time; /* event timestamp in milliseconds */
34
__s16 value; /* value */
35
__u8 type; /* event type */
36
__u8 number; /* axis/button number */
39
If the read is successful, it will return sizeof(struct js_event), unless
40
you wanted to read more than one event per read as described in section 3.1.
46
The possible values of ``type'' are
48
#define JS_EVENT_BUTTON 0x01 /* button pressed/released */
49
#define JS_EVENT_AXIS 0x02 /* joystick moved */
50
#define JS_EVENT_INIT 0x80 /* initial state of device */
52
As mentioned above, the driver will issue synthetic JS_EVENT_INIT ORed
53
events on open. That is, if it's issuing a INIT BUTTON event, the
54
current type value will be
56
int type = JS_EVENT_BUTTON | JS_EVENT_INIT; /* 0x81 */
58
If you choose not to differentiate between synthetic or real events
59
you can turn off the JS_EVENT_INIT bits
61
type &= ~JS_EVENT_INIT; /* 0x01 */
67
The values of ``number'' correspond to the axis or button that
68
generated the event. Note that they carry separate numeration (that
69
is, you have both an axis 0 and a button 0). Generally,
78
Hats vary from one joystick type to another. Some can be moved in 8
79
directions, some only in 4, The driver, however, always reports a hat as two
80
independent axis, even if the hardware doesn't allow independent movement.
86
For an axis, ``value'' is a signed integer between -32767 and +32767
87
representing the position of the joystick along that axis. If you
88
don't read a 0 when the joystick is `dead', or if it doesn't span the
89
full range, you should recalibrate it (with, for example, jscal).
91
For a button, ``value'' for a press button event is 1 and for a release
96
if (js_event.type == JS_EVENT_BUTTON) {
97
buttons_state ^= (1 << js_event.number);
100
may work well if you handle JS_EVENT_INIT events separately,
102
if ((js_event.type & ~JS_EVENT_INIT) == JS_EVENT_BUTTON) {
104
buttons_state |= (1 << js_event.number);
106
buttons_state &= ~(1 << js_event.number);
109
is much safer since it can't lose sync with the driver. As you would
110
have to write a separate handler for JS_EVENT_INIT events in the first
111
snippet, this ends up being shorter.
117
The time an event was generated is stored in ``js_event.time''. It's a time
118
in milliseconds since ... well, since sometime in the past. This eases the
119
task of detecting double clicks, figuring out if movement of axis and button
120
presses happened at the same time, and similar.
126
If you open the device in blocking mode, a read will block (that is,
127
wait) forever until an event is generated and effectively read. There
128
are two alternatives if you can't afford to wait forever (which is,
129
admittedly, a long time;)
131
a) use select to wait until there's data to be read on fd, or
132
until it timeouts. There's a good example on the select(2)
135
b) open the device in non-blocking mode (O_NONBLOCK)
141
If read returns -1 when reading in O_NONBLOCK mode, this isn't
142
necessarily a "real" error (check errno(3)); it can just mean there
143
are no events pending to be read on the driver queue. You should read
144
all events on the queue (that is, until you get a -1).
149
while (read (fd, &e, sizeof(struct js_event)) > 0) {
152
/* EAGAIN is returned when the queue is empty */
153
if (errno != EAGAIN) {
156
/* do something interesting with processed events */
159
One reason for emptying the queue is that if it gets full you'll start
160
missing events since the queue is finite, and older events will get
163
The other reason is that you want to know all what happened, and not
164
delay the processing till later.
166
Why can get the queue full? Because you don't empty the queue as
167
mentioned, or because too much time elapses from one read to another
168
and too many events to store in the queue get generated. Note that
169
high system load may contribute to space those reads even more.
171
If time between reads is enough to fill the queue and loose an event,
172
the driver will switch to startup mode and next time you read it,
173
synthetic events (JS_EVENT_INIT) will be generated to inform you of
174
the actual state of the joystick.
176
[As for version 1.2.8, the queue is circular and able to hold 64
177
events. You can increment this size bumping up JS_BUFF_SIZE in
178
joystick.h and recompiling the driver.]
181
In the above code, you might as well want to read more than one event
182
at a time using the typical read(2) functionality. For that, you would
183
replace the read above with something like
185
struct js_event mybuffer[0xff];
186
int i = read (fd, mybuffer, sizeof(struct mybuffer));
188
In this case, read would return -1 if the queue was empty, or some
189
other value in which the number of events read would be i /
190
sizeof(js_event) Again, if the buffer was full, it's a good idea to
191
process the events and keep reading it until you empty the driver queue.
197
The joystick driver defines the following ioctl(2) operations.
199
/* function 3rd arg */
200
#define JSIOCGAXES /* get number of axes char */
201
#define JSIOCGBUTTONS /* get number of buttons char */
202
#define JSIOCGVERSION /* get driver version int */
203
#define JSIOCGNAME(len) /* get identifier string char */
204
#define JSIOCSCORR /* set correction values &js_corr */
205
#define JSIOCGCORR /* get correction values &js_corr */
207
For example, to read the number of axes
210
ioctl (fd, JSIOCGAXES, &number_of_axes);
216
JSIOGCVERSION is a good way to check in run-time whether the running
217
driver is 1.0+ and supports the event interface. If it is not, the
218
IOCTL will fail. For a compile-time decision, you can test the
222
#if JS_VERSION > 0xsomething
228
JSIOCGNAME(len) allows you to get the name string of the joystick - the same
229
as is being printed at boot time. The 'len' argument is the length of the
230
buffer provided by the application asking for the name. It is used to avoid
231
possible overrun should the name be too long.
234
if (ioctl(fd, JSIOCGNAME(sizeof(name)), name) < 0)
235
strncpy(name, "Unknown", sizeof(name));
236
printf("Name: %s\n", name);
242
For usage on JSIOC[SG]CORR I suggest you to look into jscal.c They are
243
not needed in a normal program, only in joystick calibration software
244
such as jscal or kcmjoy. These IOCTLs and data types aren't considered
245
to be in the stable part of the API, and therefore may change without
246
warning in following releases of the driver.
248
Both JSIOCSCORR and JSIOCGCORR expect &js_corr to be able to hold
249
information for all axis. That is, struct js_corr corr[MAX_AXIS];
251
struct js_corr is defined as
261
#define JS_CORR_NONE 0x00 /* returns raw values */
262
#define JS_CORR_BROKEN 0x01 /* broken line */
265
5. Backward compatibility
266
~~~~~~~~~~~~~~~~~~~~~~~~~
268
The 0.x joystick driver API is quite limited and its usage is deprecated.
269
The driver offers backward compatibility, though. Here's a quick summary:
271
struct JS_DATA_TYPE js;
273
if (read (fd, &js, JS_RETURN) != JS_RETURN) {
279
As you can figure out from the example, the read returns immediately,
280
with the actual state of the joystick.
282
struct JS_DATA_TYPE {
283
int buttons; /* immediate button state */
284
int x; /* immediate x axis value */
285
int y; /* immediate y axis value */
288
and JS_RETURN is defined as
290
#define JS_RETURN sizeof(struct JS_DATA_TYPE)
292
To test the state of the buttons,
294
first_button_state = js.buttons & 1;
295
second_button_state = js.buttons & 2;
297
The axis values do not have a defined range in the original 0.x driver,
298
except for that the values are non-negative. The 1.2.8+ drivers use a
299
fixed range for reporting the values, 1 being the minimum, 128 the
300
center, and 255 maximum value.
302
The v0.8.0.2 driver also had an interface for 'digital joysticks', (now
303
called Multisystem joysticks in this driver), under /dev/djsX. This driver
304
doesn't try to be compatible with that interface.
310
____/| Comments, additions, and specially corrections are welcome.
311
\ o.O| Documentation valid for at least version 1.2.8 of the joystick
312
=(_)= driver and as usual, the ultimate source for documentation is
313
U to "Use The Source Luke" or, at your convenience, Vojtech ;)
added
removed
linux/Documentation/input/joystick-api.txt
