rik/libwiiuse
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

astyle on the library.

Browse Source
This commit is contained in:
Ryan Pavlik
2012-12-10 14:13:58 -06:00
parent 82080f9f37
commit a86f33afa5
23 changed files with 1168 additions and 1056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/classic.c
View File

@@ -77,8 +77,9 @@ int classic_ctrl_handshake(struct wiimote_t* wm, struct classic_ctrl_t* cc, byte
wiiuse_read_data_cb(wm, handshake_expansion, handshake_buf, WM_EXP_MEM_CALIBR, EXP_HANDSHAKE_LEN); wiiuse_read_data_cb(wm, handshake_expansion, handshake_buf, WM_EXP_MEM_CALIBR, EXP_HANDSHAKE_LEN);
return 0; return 0;
} else } else {
data += 16; data += 16;
}
} }
@@ -100,9 +101,9 @@ int classic_ctrl_handshake(struct wiimote_t* wm, struct classic_ctrl_t* cc, byte
/* handshake done */ /* handshake done */
wm->exp.type = EXP_CLASSIC; wm->exp.type = EXP_CLASSIC;
#ifdef WIIUSE_WIN32 #ifdef WIIUSE_WIN32
wm->timeout = WIIMOTE_DEFAULT_TIMEOUT; wm->timeout = WIIMOTE_DEFAULT_TIMEOUT;
#endif #endif
return 1; return 1;
} }

12
src/classic.h
View File

@@ -40,14 +40,14 @@
extern "C" { extern "C" {
#endif #endif
/** @defgroup internal_classic Internal: Classic Controller */ /** @defgroup internal_classic Internal: Classic Controller */
/** @{ */ /** @{ */
int classic_ctrl_handshake(struct wiimote_t* wm, struct classic_ctrl_t* cc, byte* data, unsigned short len); int classic_ctrl_handshake(struct wiimote_t* wm, struct classic_ctrl_t* cc, byte* data, unsigned short len);
void classic_ctrl_disconnected(struct classic_ctrl_t* cc); void classic_ctrl_disconnected(struct classic_ctrl_t* cc);
void classic_ctrl_event(struct classic_ctrl_t* cc, byte* msg); void classic_ctrl_event(struct classic_ctrl_t* cc, byte* msg);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

77
src/dynamics.c
View File

@@ -77,12 +77,21 @@ void calculate_orientation(struct accel_t* ac, struct vec3b_t* accel, struct ori
z = ((float)accel->z - (float)ac->cal_zero.z) / zg; z = ((float)accel->z - (float)ac->cal_zero.z) / zg;
/* make sure x,y,z are between -1 and 1 for the tan functions */ /* make sure x,y,z are between -1 and 1 for the tan functions */
if (x < -1.0f) x = -1.0f; if (x < -1.0f) {
else if (x > 1.0f) x = 1.0f; x = -1.0f;
if (y < -1.0f) y = -1.0f; } else if (x > 1.0f) {
else if (y > 1.0f) y = 1.0f; x = 1.0f;
if (z < -1.0f) z = -1.0f; }
else if (z > 1.0f) z = 1.0f; if (y < -1.0f) {
y = -1.0f;
} else if (y > 1.0f) {
y = 1.0f;
}
if (z < -1.0f) {
z = -1.0f;
} else if (z > 1.0f) {
z = 1.0f;
}
/* if it is over 1g then it is probably accelerating and not reliable */ /* if it is over 1g then it is probably accelerating and not reliable */
if (abs(accel->x - ac->cal_zero.x) <= ac->cal_g.x) { if (abs(accel->x - ac->cal_zero.x) <= ac->cal_g.x) {
@@ -180,39 +189,39 @@ void calc_joystick_state(struct joystick_t* js, float x, float y) {
void apply_smoothing(struct accel_t* ac, struct orient_t* orient, int type) { void apply_smoothing(struct accel_t* ac, struct orient_t* orient, int type) {
switch (type) { switch (type) {
case SMOOTH_ROLL: case SMOOTH_ROLL: {
{ /* it's possible last iteration was nan or inf, so set it to 0 if that happened */
/* it's possible last iteration was nan or inf, so set it to 0 if that happened */ if (isnan(ac->st_roll) || isinf(ac->st_roll)) {
if (isnan(ac->st_roll) || isinf(ac->st_roll)) ac->st_roll = 0.0f;
ac->st_roll = 0.0f; }
/* /*
* If the sign changes (which will happen if going from -180 to 180) * If the sign changes (which will happen if going from -180 to 180)
* or from (-1 to 1) then don't smooth, just use the new angle. * or from (-1 to 1) then don't smooth, just use the new angle.
*/ */
if (((ac->st_roll < 0) && (orient->roll > 0)) || ((ac->st_roll > 0) && (orient->roll < 0))) { if (((ac->st_roll < 0) && (orient->roll > 0)) || ((ac->st_roll > 0) && (orient->roll < 0))) {
ac->st_roll = orient->roll; ac->st_roll = orient->roll;
} else { } else {
orient->roll = ac->st_roll + (ac->st_alpha * (orient->a_roll - ac->st_roll)); orient->roll = ac->st_roll + (ac->st_alpha * (orient->a_roll - ac->st_roll));
ac->st_roll = orient->roll; ac->st_roll = orient->roll;
}
return;
} }
return; case SMOOTH_PITCH: {
} if (isnan(ac->st_pitch) || isinf(ac->st_pitch)) {
ac->st_pitch = 0.0f;
}
case SMOOTH_PITCH: if (((ac->st_pitch < 0) && (orient->pitch > 0)) || ((ac->st_pitch > 0) && (orient->pitch < 0))) {
{ ac->st_pitch = orient->pitch;
if (isnan(ac->st_pitch) || isinf(ac->st_pitch)) } else {
ac->st_pitch = 0.0f; orient->pitch = ac->st_pitch + (ac->st_alpha * (orient->a_pitch - ac->st_pitch));
ac->st_pitch = orient->pitch;
}
if (((ac->st_pitch < 0) && (orient->pitch > 0)) || ((ac->st_pitch > 0) && (orient->pitch < 0))) { return;
ac->st_pitch = orient->pitch;
} else {
orient->pitch = ac->st_pitch + (ac->st_alpha * (orient->a_pitch - ac->st_pitch));
ac->st_pitch = orient->pitch;
} }
return;
}
} }
} }

14
src/dynamics.h
View File

@@ -44,14 +44,14 @@
extern "C" { extern "C" {
#endif #endif
/** @defgroup internal_dynamics Internal: Dynamics Functions */ /** @defgroup internal_dynamics Internal: Dynamics Functions */
/** @{ */ /** @{ */
void calculate_orientation(struct accel_t* ac, struct vec3b_t* accel, struct orient_t* orient, int smooth); void calculate_orientation(struct accel_t* ac, struct vec3b_t* accel, struct orient_t* orient, int smooth);
void calculate_gforce(struct accel_t* ac, struct vec3b_t* accel, struct gforce_t* gforce); void calculate_gforce(struct accel_t* ac, struct vec3b_t* accel, struct gforce_t* gforce);
void calc_joystick_state(struct joystick_t* js, float x, float y); void calc_joystick_state(struct joystick_t* js, float x, float y);
void apply_smoothing(struct accel_t* ac, struct orient_t* orient, int type); void apply_smoothing(struct accel_t* ac, struct orient_t* orient, int type);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

439
src/events.c
View File

@@ -99,7 +99,7 @@ int wiiuse_update(struct wiimote_t** wiimotes, int nwiimotes, wiiuse_update_cb c
s.event = wiimotes[i]->event; s.event = wiimotes[i]->event;
s.state = wiimotes[i]->state; s.state = wiimotes[i]->state;
s.expansion = wiimotes[i]->exp; s.expansion = wiimotes[i]->exp;
callback( &s ); callback(&s);
evnt++; evnt++;
break; break;
} }
@@ -184,108 +184,98 @@ void propagate_event(struct wiimote_t* wm, byte event, byte* msg) {
save_state(wm); save_state(wm);
switch (event) { switch (event) {
case WM_RPT_BTN: case WM_RPT_BTN: {
{ /* button */
/* button */ wiiuse_pressed_buttons(wm, msg);
wiiuse_pressed_buttons(wm, msg); break;
break; }
} case WM_RPT_BTN_ACC: {
case WM_RPT_BTN_ACC: /* button - motion */
{ wiiuse_pressed_buttons(wm, msg);
/* button - motion */
wiiuse_pressed_buttons(wm, msg);
handle_wm_accel(wm, msg); handle_wm_accel(wm, msg);
break; break;
} }
case WM_RPT_READ: case WM_RPT_READ: {
{ /* data read */
/* data read */ event_data_read(wm, msg);
event_data_read(wm, msg);
/* yeah buttons may be pressed, but this wasn't an "event" */ /* yeah buttons may be pressed, but this wasn't an "event" */
return; return;
} }
case WM_RPT_CTRL_STATUS: case WM_RPT_CTRL_STATUS: {
{ /* controller status */
/* controller status */ event_status(wm, msg);
event_status(wm, msg);
/* don't execute the event callback */ /* don't execute the event callback */
return; return;
} }
case WM_RPT_BTN_EXP: case WM_RPT_BTN_EXP: {
{ /* button - expansion */
/* button - expansion */ wiiuse_pressed_buttons(wm, msg);
wiiuse_pressed_buttons(wm, msg); handle_expansion(wm, msg + 2);
handle_expansion(wm, msg+2);
break; break;
} }
case WM_RPT_BTN_ACC_EXP: case WM_RPT_BTN_ACC_EXP: {
{ /* button - motion - expansion */
/* button - motion - expansion */ wiiuse_pressed_buttons(wm, msg);
wiiuse_pressed_buttons(wm, msg);
handle_wm_accel(wm, msg); handle_wm_accel(wm, msg);
handle_expansion(wm, msg+5); handle_expansion(wm, msg + 5);
break; break;
} }
case WM_RPT_BTN_ACC_IR: case WM_RPT_BTN_ACC_IR: {
{ /* button - motion - ir */
/* button - motion - ir */ wiiuse_pressed_buttons(wm, msg);
wiiuse_pressed_buttons(wm, msg);
handle_wm_accel(wm, msg); handle_wm_accel(wm, msg);
/* ir */ /* ir */
calculate_extended_ir(wm, msg+5); calculate_extended_ir(wm, msg + 5);
break; break;
} }
case WM_RPT_BTN_IR_EXP: case WM_RPT_BTN_IR_EXP: {
{ /* button - ir - expansion */
/* button - ir - expansion */ wiiuse_pressed_buttons(wm, msg);
wiiuse_pressed_buttons(wm, msg); handle_expansion(wm, msg + 12);
handle_expansion(wm, msg+12);
/* ir */ /* ir */
calculate_basic_ir(wm, msg+2); calculate_basic_ir(wm, msg + 2);
break; break;
} }
case WM_RPT_BTN_ACC_IR_EXP: case WM_RPT_BTN_ACC_IR_EXP: {
{ /* button - motion - ir - expansion */
/* button - motion - ir - expansion */ wiiuse_pressed_buttons(wm, msg);
wiiuse_pressed_buttons(wm, msg);
handle_wm_accel(wm, msg); handle_wm_accel(wm, msg);
handle_expansion(wm, msg+15); handle_expansion(wm, msg + 15);
/* ir */ /* ir */
calculate_basic_ir(wm, msg+5); calculate_basic_ir(wm, msg + 5);
break; break;
} }
case WM_RPT_WRITE: case WM_RPT_WRITE: {
{ event_data_write(wm, msg);
event_data_write(wm,msg); break;
break; }
} default: {
default: WIIUSE_WARNING("Unknown event, can not handle it [Code 0x%x].", event);
{ return;
WIIUSE_WARNING("Unknown event, can not handle it [Code 0x%x].", event); }
return;
}
} }
/* was there an event? */ /* was there an event? */
if (state_changed(wm)) if (state_changed(wm)) {
wm->event = WIIUSE_EVENT; wm->event = WIIUSE_EVENT;
}
} }
@@ -334,8 +324,9 @@ static void event_data_read(struct wiimote_t* wm, byte* msg) {
wiiuse_pressed_buttons(wm, msg); wiiuse_pressed_buttons(wm, msg);
/* find the next non-dirty request */ /* find the next non-dirty request */
while (req && req->dirty) while (req && req->dirty) {
req = req->next; req = req->next;
}
/* if we don't have a request out then we didn't ask for this packet */ /* if we don't have a request out then we didn't ask for this packet */
if (!req) { if (!req) {
@@ -345,12 +336,13 @@ static void event_data_read(struct wiimote_t* wm, byte* msg) {
err = msg[2] & 0x0F; err = msg[2] & 0x0F;
if (err == 0x08) if (err == 0x08) {
WIIUSE_WARNING("Unable to read data - address does not exist."); WIIUSE_WARNING("Unable to read data - address does not exist.");
else if (err == 0x07) } else if (err == 0x07) {
WIIUSE_WARNING("Unable to read data - address is for write-only registers."); WIIUSE_WARNING("Unable to read data - address is for write-only registers.");
else if (err) } else if (err) {
WIIUSE_WARNING("Unable to read data - unknown error code %x.", err); WIIUSE_WARNING("Unable to read data - unknown error code %x.", err);
}
if (err) { if (err) {
/* this request errored out, so skip it and go to the next one */ /* this request errored out, so skip it and go to the next one */
@@ -360,8 +352,9 @@ static void event_data_read(struct wiimote_t* wm, byte* msg) {
free(req); free(req);
/* if another request exists send it to the wiimote */ /* if another request exists send it to the wiimote */
if (wm->read_req) if (wm->read_req) {
wiiuse_send_next_pending_read_request(wm); wiiuse_send_next_pending_read_request(wm);
}
return; return;
} }
@@ -373,7 +366,9 @@ static void event_data_read(struct wiimote_t* wm, byte* msg) {
req->wait -= len; req->wait -= len;
if (req->wait >= req->size) if (req->wait >= req->size)
/* this should never happen */ /* this should never happen */
{
req->wait = 0; req->wait = 0;
}
WIIUSE_DEBUG("Received read packet:"); WIIUSE_DEBUG("Received read packet:");
WIIUSE_DEBUG(" Packet read offset: %i bytes", offset); WIIUSE_DEBUG(" Packet read offset: %i bytes", offset);
@@ -385,15 +380,16 @@ static void event_data_read(struct wiimote_t* wm, byte* msg) {
/* reconstruct this part of the data */ /* reconstruct this part of the data */
memcpy((req->buf + offset - req->addr), (msg + 5), len); memcpy((req->buf + offset - req->addr), (msg + 5), len);
#ifdef WITH_WIIUSE_DEBUG #ifdef WITH_WIIUSE_DEBUG
{ {
int i = 0; int i = 0;
printf("Read: "); printf("Read: ");
for (; i < req->size - req->wait; ++i) for (; i < req->size - req->wait; ++i) {
printf("%x ", req->buf[i]); printf("%x ", req->buf[i]);
}
printf("\n"); printf("\n");
} }
#endif #endif
/* if all data has been received, execute the read event callback or generate event */ /* if all data has been received, execute the read event callback or generate event */
if (!req->wait) { if (!req->wait) {
@@ -417,25 +413,25 @@ static void event_data_read(struct wiimote_t* wm, byte* msg) {
} }
/* if another request exists send it to the wiimote */ /* if another request exists send it to the wiimote */
if (wm->read_req) if (wm->read_req) {
wiiuse_send_next_pending_read_request(wm); wiiuse_send_next_pending_read_request(wm);
}
} }
} }
static void event_data_write(struct wiimote_t *wm, byte *msg) static void event_data_write(struct wiimote_t *wm, byte *msg) {
{
struct data_req_t* req = wm->data_req; struct data_req_t* req = wm->data_req;
wiiuse_pressed_buttons(wm,msg); wiiuse_pressed_buttons(wm, msg);
/* if we don't have a request out then we didn't ask for this packet */ /* if we don't have a request out then we didn't ask for this packet */
if (!req) { if (!req) {
WIIUSE_WARNING("Transmitting data packet when no request was made."); WIIUSE_WARNING("Transmitting data packet when no request was made.");
return; return;
} }
if(!(req->state==REQ_SENT)) { if (!(req->state == REQ_SENT)) {
WIIUSE_WARNING("Transmission is not necessary"); WIIUSE_WARNING("Transmission is not necessary");
/* delete this request */ /* delete this request */
wm->data_req = req->next; wm->data_req = req->next;
@@ -446,23 +442,23 @@ static void event_data_write(struct wiimote_t *wm, byte *msg)
req->state = REQ_DONE; req->state = REQ_DONE;
if(req->cb) { if (req->cb) {
/* this was a callback, so invoke it now */ /* this was a callback, so invoke it now */
req->cb(wm,NULL,0); req->cb(wm, NULL, 0);
/* delete this request */ /* delete this request */
wm->data_req = req->next; wm->data_req = req->next;
free(req); free(req);
} else { } else {
/* /*
* This should generate an event. * This should generate an event.
* We need to leave the event in the array so the client * We need to leave the event in the array so the client
* can access it still. We'll flag is as being 'REQ_DONE' * can access it still. We'll flag is as being 'REQ_DONE'
* and give the client one cycle to use it. Next event * and give the client one cycle to use it. Next event
* we will remove it from the list. * we will remove it from the list.
*/ */
wm->event = WIIUSE_WRITE_DATA; wm->event = WIIUSE_WRITE_DATA;
} }
/* if another request exists send it to the wiimote */ /* if another request exists send it to the wiimote */
if (wm->data_req) { if (wm->data_req) {
wiiuse_send_next_pending_write_request(wm); wiiuse_send_next_pending_write_request(wm);
@@ -485,8 +481,9 @@ static void event_status(struct wiimote_t* wm, byte* msg) {
struct data_req_t* req = wm->data_req; struct data_req_t* req = wm->data_req;
/* initial handshake is not finished yet, ignore this */ /* initial handshake is not finished yet, ignore this */
if(WIIMOTE_IS_SET(wm, WIIMOTE_STATE_HANDSHAKE)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_HANDSHAKE)) {
return; return;
}
/* /*
* An event occurred. * An event occurred.
@@ -498,29 +495,39 @@ static void event_status(struct wiimote_t* wm, byte* msg) {
wiiuse_pressed_buttons(wm, msg); wiiuse_pressed_buttons(wm, msg);
/* find what LEDs are lit */ /* find what LEDs are lit */
if (msg[2] & WM_CTRL_STATUS_BYTE1_LED_1) led[0] = 1; if (msg[2] & WM_CTRL_STATUS_BYTE1_LED_1) {
if (msg[2] & WM_CTRL_STATUS_BYTE1_LED_2) led[1] = 1; led[0] = 1;
if (msg[2] & WM_CTRL_STATUS_BYTE1_LED_3) led[2] = 1; }
if (msg[2] & WM_CTRL_STATUS_BYTE1_LED_4) led[3] = 1; if (msg[2] & WM_CTRL_STATUS_BYTE1_LED_2) {
led[1] = 1;
}
if (msg[2] & WM_CTRL_STATUS_BYTE1_LED_3) {
led[2] = 1;
}
if (msg[2] & WM_CTRL_STATUS_BYTE1_LED_4) {
led[3] = 1;
}
/* probe for Motion+ */ /* probe for Motion+ */
if(!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_MPLUS_PRESENT)) if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_MPLUS_PRESENT)) {
wiiuse_probe_motion_plus(wm); wiiuse_probe_motion_plus(wm);
}
/* is an attachment connected to the expansion port? */ /* is an attachment connected to the expansion port? */
if ((msg[2] & WM_CTRL_STATUS_BYTE1_ATTACHMENT) == WM_CTRL_STATUS_BYTE1_ATTACHMENT) if ((msg[2] & WM_CTRL_STATUS_BYTE1_ATTACHMENT) == WM_CTRL_STATUS_BYTE1_ATTACHMENT) {
{
WIIUSE_DEBUG("Attachment detected!"); WIIUSE_DEBUG("Attachment detected!");
attachment = 1; attachment = 1;
} }
/* is the speaker enabled? */ /* is the speaker enabled? */
if ((msg[2] & WM_CTRL_STATUS_BYTE1_SPEAKER_ENABLED) == WM_CTRL_STATUS_BYTE1_SPEAKER_ENABLED) if ((msg[2] & WM_CTRL_STATUS_BYTE1_SPEAKER_ENABLED) == WM_CTRL_STATUS_BYTE1_SPEAKER_ENABLED) {
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_SPEAKER); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_SPEAKER);
}
/* is IR sensing enabled? */ /* is IR sensing enabled? */
if ((msg[2] & WM_CTRL_STATUS_BYTE1_IR_ENABLED) == WM_CTRL_STATUS_BYTE1_IR_ENABLED) if ((msg[2] & WM_CTRL_STATUS_BYTE1_IR_ENABLED) == WM_CTRL_STATUS_BYTE1_IR_ENABLED) {
ir = 1; ir = 1;
}
/* find the battery level and normalize between 0 and 1 */ /* find the battery level and normalize between 0 and 1 */
wm->battery_level = (msg[5] / (float)WM_MAX_BATTERY_CODE); wm->battery_level = (msg[5] / (float)WM_MAX_BATTERY_CODE);
@@ -536,20 +543,19 @@ static void event_status(struct wiimote_t* wm, byte* msg) {
exp_changed = 1; exp_changed = 1;
} }
#ifdef WIIUSE_WIN32 #ifdef WIIUSE_WIN32
if (!attachment) { if (!attachment) {
WIIUSE_DEBUG("Setting timeout to normal %i ms.", wm->normal_timeout); WIIUSE_DEBUG("Setting timeout to normal %i ms.", wm->normal_timeout);
wm->timeout = wm->normal_timeout; wm->timeout = wm->normal_timeout;
} }
#endif #endif
/* /*
* From now on the remote will only send status packets. * From now on the remote will only send status packets.
* We need to send a WIIMOTE_CMD_REPORT_TYPE packet to * We need to send a WIIMOTE_CMD_REPORT_TYPE packet to
* reenable other incoming reports. * reenable other incoming reports.
*/ */
if (exp_changed && WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) if (exp_changed && WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) {
{
/* /*
* Since the expansion status changed IR needs to * Since the expansion status changed IR needs to
* be reset for the new IR report mode. * be reset for the new IR report mode.
@@ -562,8 +568,12 @@ static void event_status(struct wiimote_t* wm, byte* msg) {
} }
/* handling new Tx for changed exp */ /* handling new Tx for changed exp */
if(!req) return; if (!req) {
if(!(req->state==REQ_SENT)) return; return;
}
if (!(req->state == REQ_SENT)) {
return;
}
wm->data_req = req->next; wm->data_req = req->next;
req->state = REQ_DONE; req->state = REQ_DONE;
/* if(req->cb!=NULL) req->cb(wm,msg,6); */ /* if(req->cb!=NULL) req->cb(wm,msg,6); */
@@ -623,8 +633,8 @@ void handshake_expansion(struct wiimote_t* wm, byte* data, uint16_t len) {
int gotIt = 0; int gotIt = 0;
WIIUSE_DEBUG("handshake_expansion with state %d", wm->expansion_state); WIIUSE_DEBUG("handshake_expansion with state %d", wm->expansion_state);
switch(wm->expansion_state) { switch (wm->expansion_state) {
/* These two initialization writes disable the encryption */ /* These two initialization writes disable the encryption */
case 0: case 0:
wm->expansion_state = 1; wm->expansion_state = 1;
/* increase the timeout until the handshake completes */ /* increase the timeout until the handshake completes */
@@ -648,22 +658,23 @@ void handshake_expansion(struct wiimote_t* wm, byte* data, uint16_t len) {
case 2: case 2:
wm->expansion_state = 3; wm->expansion_state = 3;
/* get the calibration data */ /* get the calibration data */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP)) {
disable_expansion(wm); disable_expansion(wm);
}
handshake_buf = malloc(EXP_HANDSHAKE_LEN * sizeof(byte)); handshake_buf = malloc(EXP_HANDSHAKE_LEN * sizeof(byte));
/* tell the wiimote to send expansion data */ /* tell the wiimote to send expansion data */
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_EXP); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_EXP);
wiiuse_read_data_cb(wm, handshake_expansion, handshake_buf, WM_EXP_MEM_CALIBR, EXP_HANDSHAKE_LEN); wiiuse_read_data_cb(wm, handshake_expansion, handshake_buf, WM_EXP_MEM_CALIBR, EXP_HANDSHAKE_LEN);
break; break;
case 3: case 3:
if(!data || !len) { if (!data || !len) {
WIIUSE_DEBUG("no handshake data received from expansion"); WIIUSE_DEBUG("no handshake data received from expansion");
disable_expansion(wm); disable_expansion(wm);
return; return;
} }
wm->expansion_state = 0; wm->expansion_state = 0;
id = from_big_endian_uint32_t(data + 220); id = from_big_endian_uint32_t(data + 220);
switch(id) { switch (id) {
case EXP_ID_CODE_NUNCHUK: case EXP_ID_CODE_NUNCHUK:
if (nunchuk_handshake(wm, &wm->exp.nunchuk, data, len)) { if (nunchuk_handshake(wm, &wm->exp.nunchuk, data, len)) {
wm->event = WIIUSE_NUNCHUK_INSERTED; wm->event = WIIUSE_NUNCHUK_INSERTED;
@@ -693,12 +704,12 @@ void handshake_expansion(struct wiimote_t* wm, byte* data, uint16_t len) {
gotIt = 1; gotIt = 1;
break; break;
case EXP_ID_CODE_WII_BOARD: case EXP_ID_CODE_WII_BOARD:
if(wii_board_handshake(wm, &wm->exp.wb, data, len)) { if (wii_board_handshake(wm, &wm->exp.wb, data, len)) {
wm->event = WIIUSE_WII_BOARD_CTRL_INSERTED; wm->event = WIIUSE_WII_BOARD_CTRL_INSERTED;
gotIt = 1; gotIt = 1;
} }
break; break;
default: default:
WIIUSE_WARNING("Unknown expansion type. Code: 0x%x", id); WIIUSE_WARNING("Unknown expansion type. Code: 0x%x", id);
@@ -706,8 +717,8 @@ void handshake_expansion(struct wiimote_t* wm, byte* data, uint16_t len) {
} }
free(data); free(data);
if (gotIt) { if (gotIt) {
WIIMOTE_DISABLE_STATE(wm,WIIMOTE_STATE_EXP_HANDSHAKE); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE);
WIIMOTE_ENABLE_STATE(wm,WIIMOTE_STATE_EXP); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_EXP);
} else { } else {
WIIUSE_WARNING("Could not handshake with expansion id: 0x%x", id); WIIUSE_WARNING("Could not handshake with expansion id: 0x%x", id);
} }
@@ -731,8 +742,9 @@ void handshake_expansion(struct wiimote_t* wm, byte* data, uint16_t len) {
*/ */
void disable_expansion(struct wiimote_t* wm) { void disable_expansion(struct wiimote_t* wm) {
WIIUSE_DEBUG("Disabling expansion"); WIIUSE_DEBUG("Disabling expansion");
if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP)) if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP)) {
return; return;
}
/* tell the associated module the expansion was removed */ /* tell the associated module the expansion was removed */
switch (wm->exp.type) { switch (wm->exp.type) {
@@ -819,31 +831,29 @@ static void save_state(struct wiimote_t* wm) {
case EXP_MOTION_PLUS: case EXP_MOTION_PLUS:
case EXP_MOTION_PLUS_CLASSIC: case EXP_MOTION_PLUS_CLASSIC:
case EXP_MOTION_PLUS_NUNCHUK: case EXP_MOTION_PLUS_NUNCHUK: {
{ wm->lstate.drx = wm->exp.mp.raw_gyro.pitch;
wm->lstate.drx = wm->exp.mp.raw_gyro.pitch; wm->lstate.dry = wm->exp.mp.raw_gyro.roll;
wm->lstate.dry = wm->exp.mp.raw_gyro.roll; wm->lstate.drz = wm->exp.mp.raw_gyro.yaw;
wm->lstate.drz = wm->exp.mp.raw_gyro.yaw;
if(wm->exp.type == EXP_MOTION_PLUS_CLASSIC) if (wm->exp.type == EXP_MOTION_PLUS_CLASSIC) {
{ wm->lstate.exp_ljs_ang = wm->exp.classic.ljs.ang;
wm->lstate.exp_ljs_ang = wm->exp.classic.ljs.ang; wm->lstate.exp_ljs_mag = wm->exp.classic.ljs.mag;
wm->lstate.exp_ljs_mag = wm->exp.classic.ljs.mag; wm->lstate.exp_rjs_ang = wm->exp.classic.rjs.ang;
wm->lstate.exp_rjs_ang = wm->exp.classic.rjs.ang; wm->lstate.exp_rjs_mag = wm->exp.classic.rjs.mag;
wm->lstate.exp_rjs_mag = wm->exp.classic.rjs.mag; wm->lstate.exp_r_shoulder = wm->exp.classic.r_shoulder;
wm->lstate.exp_r_shoulder = wm->exp.classic.r_shoulder; wm->lstate.exp_l_shoulder = wm->exp.classic.l_shoulder;
wm->lstate.exp_l_shoulder = wm->exp.classic.l_shoulder; wm->lstate.exp_btns = wm->exp.classic.btns;
wm->lstate.exp_btns = wm->exp.classic.btns; } else {
} else { wm->lstate.exp_ljs_ang = wm->exp.nunchuk.js.ang;
wm->lstate.exp_ljs_ang = wm->exp.nunchuk.js.ang; wm->lstate.exp_ljs_mag = wm->exp.nunchuk.js.mag;
wm->lstate.exp_ljs_mag = wm->exp.nunchuk.js.mag; wm->lstate.exp_btns = wm->exp.nunchuk.btns;
wm->lstate.exp_btns = wm->exp.nunchuk.btns; wm->lstate.exp_accel = wm->exp.nunchuk.accel;
wm->lstate.exp_accel = wm->exp.nunchuk.accel; }
break;
} }
break;
}
case EXP_NONE: case EXP_NONE:
break; break;
} }
@@ -856,9 +866,9 @@ static void save_state(struct wiimote_t* wm) {
* @return 1 if a significant change occurred, 0 if not. * @return 1 if a significant change occurred, 0 if not.
*/ */
static int state_changed(struct wiimote_t* wm) { static int state_changed(struct wiimote_t* wm) {
#define STATE_CHANGED(a, b) if (a != b) return 1 #define STATE_CHANGED(a, b) if (a != b) return 1
#define CROSS_THRESH(last, now, thresh) \ #define CROSS_THRESH(last, now, thresh) \
do { \ do { \
if (WIIMOTE_IS_FLAG_SET(wm, WIIUSE_ORIENT_THRESH)) { \ if (WIIMOTE_IS_FLAG_SET(wm, WIIUSE_ORIENT_THRESH)) { \
if ((diff_f(last.roll, now.roll) >= thresh) || \ if ((diff_f(last.roll, now.roll) >= thresh) || \
@@ -875,7 +885,7 @@ static int state_changed(struct wiimote_t* wm) {
} \ } \
} while (0) } while (0)
#define CROSS_THRESH_XYZ(last, now, thresh) \ #define CROSS_THRESH_XYZ(last, now, thresh) \
do { \ do { \
if (WIIMOTE_IS_FLAG_SET(wm, WIIUSE_ORIENT_THRESH)) { \ if (WIIMOTE_IS_FLAG_SET(wm, WIIUSE_ORIENT_THRESH)) { \
if ((diff_f(last.x, now.x) >= thresh) || \ if ((diff_f(last.x, now.x) >= thresh) || \
@@ -910,54 +920,16 @@ static int state_changed(struct wiimote_t* wm) {
/* expansion */ /* expansion */
switch (wm->exp.type) { switch (wm->exp.type) {
case EXP_NUNCHUK: case EXP_NUNCHUK: {
{ STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.nunchuk.js.ang);
STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.nunchuk.js.ang); STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.nunchuk.js.mag);
STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.nunchuk.js.mag); STATE_CHANGED(wm->lstate.exp_btns, wm->exp.nunchuk.btns);
STATE_CHANGED(wm->lstate.exp_btns, wm->exp.nunchuk.btns);
CROSS_THRESH(wm->lstate.exp_orient, wm->exp.nunchuk.orient, wm->exp.nunchuk.orient_threshold); CROSS_THRESH(wm->lstate.exp_orient, wm->exp.nunchuk.orient, wm->exp.nunchuk.orient_threshold);
CROSS_THRESH_XYZ(wm->lstate.exp_accel, wm->exp.nunchuk.accel, wm->exp.nunchuk.accel_threshold); CROSS_THRESH_XYZ(wm->lstate.exp_accel, wm->exp.nunchuk.accel, wm->exp.nunchuk.accel_threshold);
break; break;
} }
case EXP_CLASSIC: case EXP_CLASSIC: {
{
STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.classic.ljs.ang);
STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.classic.ljs.mag);
STATE_CHANGED(wm->lstate.exp_rjs_ang, wm->exp.classic.rjs.ang);
STATE_CHANGED(wm->lstate.exp_rjs_mag, wm->exp.classic.rjs.mag);
STATE_CHANGED(wm->lstate.exp_r_shoulder, wm->exp.classic.r_shoulder);
STATE_CHANGED(wm->lstate.exp_l_shoulder, wm->exp.classic.l_shoulder);
STATE_CHANGED(wm->lstate.exp_btns, wm->exp.classic.btns);
break;
}
case EXP_GUITAR_HERO_3:
{
STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.gh3.js.ang);
STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.gh3.js.mag);
STATE_CHANGED(wm->lstate.exp_r_shoulder, wm->exp.gh3.whammy_bar);
STATE_CHANGED(wm->lstate.exp_btns, wm->exp.gh3.btns);
break;
}
case EXP_WII_BOARD:
{
STATE_CHANGED(wm->lstate.exp_wb_rtr,wm->exp.wb.tr);
STATE_CHANGED(wm->lstate.exp_wb_rtl,wm->exp.wb.tl);
STATE_CHANGED(wm->lstate.exp_wb_rbr,wm->exp.wb.br);
STATE_CHANGED(wm->lstate.exp_wb_rbl,wm->exp.wb.bl);
break;
}
case EXP_MOTION_PLUS:
case EXP_MOTION_PLUS_CLASSIC:
case EXP_MOTION_PLUS_NUNCHUK:
{
STATE_CHANGED(wm->lstate.drx, wm->exp.mp.raw_gyro.pitch);
STATE_CHANGED(wm->lstate.dry, wm->exp.mp.raw_gyro.roll);
STATE_CHANGED(wm->lstate.drz, wm->exp.mp.raw_gyro.yaw);
if(wm->exp.type == EXP_MOTION_PLUS_CLASSIC)
{
STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.classic.ljs.ang); STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.classic.ljs.ang);
STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.classic.ljs.mag); STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.classic.ljs.mag);
STATE_CHANGED(wm->lstate.exp_rjs_ang, wm->exp.classic.rjs.ang); STATE_CHANGED(wm->lstate.exp_rjs_ang, wm->exp.classic.rjs.ang);
@@ -965,21 +937,52 @@ static int state_changed(struct wiimote_t* wm) {
STATE_CHANGED(wm->lstate.exp_r_shoulder, wm->exp.classic.r_shoulder); STATE_CHANGED(wm->lstate.exp_r_shoulder, wm->exp.classic.r_shoulder);
STATE_CHANGED(wm->lstate.exp_l_shoulder, wm->exp.classic.l_shoulder); STATE_CHANGED(wm->lstate.exp_l_shoulder, wm->exp.classic.l_shoulder);
STATE_CHANGED(wm->lstate.exp_btns, wm->exp.classic.btns); STATE_CHANGED(wm->lstate.exp_btns, wm->exp.classic.btns);
} else { break;
STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.nunchuk.js.ang); }
STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.nunchuk.js.mag); case EXP_GUITAR_HERO_3: {
STATE_CHANGED(wm->lstate.exp_btns, wm->exp.nunchuk.btns); STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.gh3.js.ang);
STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.gh3.js.mag);
CROSS_THRESH(wm->lstate.exp_orient, wm->exp.nunchuk.orient, wm->exp.nunchuk.orient_threshold); STATE_CHANGED(wm->lstate.exp_r_shoulder, wm->exp.gh3.whammy_bar);
CROSS_THRESH_XYZ(wm->lstate.exp_accel, wm->exp.nunchuk.accel, wm->exp.nunchuk.accel_threshold); STATE_CHANGED(wm->lstate.exp_btns, wm->exp.gh3.btns);
break;
}
case EXP_WII_BOARD: {
STATE_CHANGED(wm->lstate.exp_wb_rtr, wm->exp.wb.tr);
STATE_CHANGED(wm->lstate.exp_wb_rtl, wm->exp.wb.tl);
STATE_CHANGED(wm->lstate.exp_wb_rbr, wm->exp.wb.br);
STATE_CHANGED(wm->lstate.exp_wb_rbl, wm->exp.wb.bl);
break;
} }
break; case EXP_MOTION_PLUS:
} case EXP_MOTION_PLUS_CLASSIC:
case EXP_NONE: case EXP_MOTION_PLUS_NUNCHUK: {
{ STATE_CHANGED(wm->lstate.drx, wm->exp.mp.raw_gyro.pitch);
break; STATE_CHANGED(wm->lstate.dry, wm->exp.mp.raw_gyro.roll);
} STATE_CHANGED(wm->lstate.drz, wm->exp.mp.raw_gyro.yaw);
if (wm->exp.type == EXP_MOTION_PLUS_CLASSIC) {
STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.classic.ljs.ang);
STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.classic.ljs.mag);
STATE_CHANGED(wm->lstate.exp_rjs_ang, wm->exp.classic.rjs.ang);
STATE_CHANGED(wm->lstate.exp_rjs_mag, wm->exp.classic.rjs.mag);
STATE_CHANGED(wm->lstate.exp_r_shoulder, wm->exp.classic.r_shoulder);
STATE_CHANGED(wm->lstate.exp_l_shoulder, wm->exp.classic.l_shoulder);
STATE_CHANGED(wm->lstate.exp_btns, wm->exp.classic.btns);
} else {
STATE_CHANGED(wm->lstate.exp_ljs_ang, wm->exp.nunchuk.js.ang);
STATE_CHANGED(wm->lstate.exp_ljs_mag, wm->exp.nunchuk.js.mag);
STATE_CHANGED(wm->lstate.exp_btns, wm->exp.nunchuk.btns);
CROSS_THRESH(wm->lstate.exp_orient, wm->exp.nunchuk.orient, wm->exp.nunchuk.orient_threshold);
CROSS_THRESH_XYZ(wm->lstate.exp_accel, wm->exp.nunchuk.accel, wm->exp.nunchuk.accel_threshold);
}
break;
}
case EXP_NONE: {
break;
}
} }
STATE_CHANGED(wm->lstate.btns, wm->btns); STATE_CHANGED(wm->lstate.btns, wm->btns);

7
src/guitar_hero_3.c
View File

@@ -86,8 +86,9 @@ int guitar_hero_3_handshake(struct wiimote_t* wm, struct guitar_hero_3_t* gh3, b
wiiuse_read_data_cb(wm, handshake_expansion, handshake_buf, WM_EXP_MEM_CALIBR, EXP_HANDSHAKE_LEN); wiiuse_read_data_cb(wm, handshake_expansion, handshake_buf, WM_EXP_MEM_CALIBR, EXP_HANDSHAKE_LEN);
return 0; return 0;
} else } else {
data += 16; data += 16;
}
} }
/* joystick stuff */ /* joystick stuff */
@@ -101,9 +102,9 @@ int guitar_hero_3_handshake(struct wiimote_t* wm, struct guitar_hero_3_t* gh3, b
/* handshake done */ /* handshake done */
wm->exp.type = EXP_GUITAR_HERO_3; wm->exp.type = EXP_GUITAR_HERO_3;
#ifdef WIIUSE_WIN32 #ifdef WIIUSE_WIN32
wm->timeout = WIIMOTE_DEFAULT_TIMEOUT; wm->timeout = WIIMOTE_DEFAULT_TIMEOUT;
#endif #endif
return 1; return 1;
} }

12
src/guitar_hero_3.h
View File

@@ -50,14 +50,14 @@ extern "C" {
#endif #endif
/** @defgroup internal_gh3 Internal: Guitar Hero 3 controller */ /** @defgroup internal_gh3 Internal: Guitar Hero 3 controller */
/** @{ */ /** @{ */
int guitar_hero_3_handshake(struct wiimote_t* wm, struct guitar_hero_3_t* gh3, byte* data, unsigned short len); int guitar_hero_3_handshake(struct wiimote_t* wm, struct guitar_hero_3_t* gh3, byte* data, unsigned short len);
void guitar_hero_3_disconnected(struct guitar_hero_3_t* gh3); void guitar_hero_3_disconnected(struct guitar_hero_3_t* gh3);
void guitar_hero_3_event(struct guitar_hero_3_t* gh3, byte* msg); void guitar_hero_3_event(struct guitar_hero_3_t* gh3, byte* msg);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

205
src/io.c
View File

@@ -62,7 +62,7 @@
* This function is declared in wiiuse.h * This function is declared in wiiuse.h
*/ */
int wiiuse_find(struct wiimote_t** wm, int max_wiimotes, int timeout) { int wiiuse_find(struct wiimote_t** wm, int max_wiimotes, int timeout) {
return wiiuse_os_find(wm, max_wiimotes, timeout); return wiiuse_os_find(wm, max_wiimotes, timeout);
} }
/** /**
@@ -87,7 +87,7 @@ int wiiuse_find(struct wiimote_t** wm, int max_wiimotes, int timeout) {
* This function is declared in wiiuse.h * This function is declared in wiiuse.h
*/ */
int wiiuse_connect(struct wiimote_t** wm, int wiimotes) { int wiiuse_connect(struct wiimote_t** wm, int wiimotes) {
return wiiuse_os_connect(wm, wiimotes); return wiiuse_os_connect(wm, wiimotes);
} }
/** /**
@@ -106,10 +106,10 @@ int wiiuse_connect(struct wiimote_t** wm, int wiimotes) {
* This function is declared in wiiuse.h * This function is declared in wiiuse.h
*/ */
void wiiuse_disconnect(struct wiimote_t* wm) { void wiiuse_disconnect(struct wiimote_t* wm) {
wiiuse_os_disconnect(wm); wiiuse_os_disconnect(wm);
} }
/** /**
* @brief Wait until specified report arrives and return it * @brief Wait until specified report arrives and return it
* *
* @param wm Pointer to a wiimote_t structure. * @param wm Pointer to a wiimote_t structure.
@@ -120,12 +120,10 @@ void wiiuse_disconnect(struct wiimote_t* wm) {
* report from the Wiimote. * report from the Wiimote.
* *
*/ */
void wiiuse_wait_report(struct wiimote_t *wm, int report, byte *buffer, int bufferLength) void wiiuse_wait_report(struct wiimote_t *wm, int report, byte *buffer, int bufferLength) {
{ for (;;) {
for(;;) if (wiiuse_os_read(wm, buffer, bufferLength) > 0) {
{ if (buffer[0] == report) {
if(wiiuse_os_read(wm, buffer, bufferLength) > 0) {
if(buffer[0] == report) {
break; break;
} else { } else {
WIIUSE_WARNING("(id %i) dropping report 0x%x, waiting for 0x%x", wm->unid, buffer[0], report); WIIUSE_WARNING("(id %i) dropping report 0x%x, waiting for 0x%x", wm->unid, buffer[0], report);
@@ -147,8 +145,7 @@ void wiiuse_wait_report(struct wiimote_t *wm, int report, byte *buffer, int buff
* amount of data from the Wiimote. * amount of data from the Wiimote.
* *
*/ */
void wiiuse_read_data_sync(struct wiimote_t *wm, byte memory, unsigned addr, unsigned short size, byte *data) void wiiuse_read_data_sync(struct wiimote_t *wm, byte memory, unsigned addr, unsigned short size, byte *data) {
{
byte pkt[6]; byte pkt[6];
byte buf[MAX_PAYLOAD]; byte buf[MAX_PAYLOAD];
unsigned n_full_reports; unsigned n_full_reports;
@@ -164,10 +161,10 @@ void wiiuse_read_data_sync(struct wiimote_t *wm, byte memory, unsigned addr, uns
/* read from registers or memory */ /* read from registers or memory */
pkt[0] = (memory != 0) ? 0x00 : 0x04; pkt[0] = (memory != 0) ? 0x00 : 0x04;
/* length in big endian */ /* length in big endian */
to_big_endian_uint16_t(pkt + 4, size); to_big_endian_uint16_t(pkt + 4, size);
/* send */ /* send */
wiiuse_send(wm, WM_CMD_READ_DATA, pkt, sizeof(pkt)); wiiuse_send(wm, WM_CMD_READ_DATA, pkt, sizeof(pkt));
@@ -176,16 +173,14 @@ void wiiuse_read_data_sync(struct wiimote_t *wm, byte memory, unsigned addr, uns
last_report = size % 16; last_report = size % 16;
output = data; output = data;
for(i = 0; i < n_full_reports; ++i) for (i = 0; i < n_full_reports; ++i) {
{
wiiuse_wait_report(wm, WM_RPT_READ, buf, MAX_PAYLOAD); wiiuse_wait_report(wm, WM_RPT_READ, buf, MAX_PAYLOAD);
memmove(output, buf + 6, 16); memmove(output, buf + 6, 16);
output += 16; output += 16;
} }
/* read the last incomplete packet */ /* read the last incomplete packet */
if(last_report) if (last_report) {
{
wiiuse_wait_report(wm, WM_RPT_READ, buf, MAX_PAYLOAD); wiiuse_wait_report(wm, WM_RPT_READ, buf, MAX_PAYLOAD);
memmove(output, buf + 6, last_report); memmove(output, buf + 6, last_report);
} }
@@ -207,8 +202,7 @@ void wiiuse_read_data_sync(struct wiimote_t *wm, byte memory, unsigned addr, uns
#ifdef WIIUSE_SYNC_HANDSHAKE #ifdef WIIUSE_SYNC_HANDSHAKE
void wiiuse_handshake(struct wiimote_t* wm, byte* data, uint16_t len) void wiiuse_handshake(struct wiimote_t* wm, byte* data, uint16_t len) {
{
/* send request to wiimote for accelerometer calibration */ /* send request to wiimote for accelerometer calibration */
byte buf[MAX_PAYLOAD]; byte buf[MAX_PAYLOAD];
@@ -254,118 +248,113 @@ void wiiuse_handshake(struct wiimote_t* wm, byte* data, uint16_t len)
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_HANDSHAKE); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_HANDSHAKE);
/* now enable IR if it was set before the handshake completed */ /* now enable IR if it was set before the handshake completed */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) {
{ WIIUSE_DEBUG("Handshake finished, enabling IR.");
WIIUSE_DEBUG("Handshake finished, enabling IR."); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_IR);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_IR); wiiuse_set_ir(wm, 1);
wiiuse_set_ir(wm, 1); }
}
WIIUSE_DEBUG("Asking for status ...\n"); WIIUSE_DEBUG("Asking for status ...\n");
wm->event = WIIUSE_CONNECT; wm->event = WIIUSE_CONNECT;
wiiuse_status(wm); wiiuse_status(wm);
} }
} }
#else #else
static void wiiuse_disable_motion_plus1(struct wiimote_t *wm,byte *data,unsigned short len); static void wiiuse_disable_motion_plus1(struct wiimote_t *wm, byte *data, unsigned short len);
static void wiiuse_disable_motion_plus2(struct wiimote_t *wm,byte *data,unsigned short len); static void wiiuse_disable_motion_plus2(struct wiimote_t *wm, byte *data, unsigned short len);
void wiiuse_handshake(struct wiimote_t* wm, byte* data, uint16_t len) { void wiiuse_handshake(struct wiimote_t* wm, byte* data, uint16_t len) {
if (!wm) return; if (!wm) {
return;
}
switch (wm->handshake_state) { switch (wm->handshake_state) {
case 0: case 0: {
{ byte* buf;
byte* buf;
/* continous reporting off, report to buttons only */ /* continous reporting off, report to buttons only */
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_HANDSHAKE); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_HANDSHAKE);
wiiuse_set_leds(wm, WIIMOTE_LED_NONE); wiiuse_set_leds(wm, WIIMOTE_LED_NONE);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_ACC); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_ACC);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_IR);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_RUMBLE);
WIIMOTE_DISABLE_FLAG(wm, WIIUSE_CONTINUOUS);
wiiuse_set_report_type(wm);
/* send request to wiimote for accelerometer calibration */
buf = (byte*)malloc(sizeof(byte) * 8);
wiiuse_read_data_cb(wm, wiiuse_handshake, buf, WM_MEM_OFFSET_CALIBRATION, 7);
wm->handshake_state++;
wiiuse_set_leds(wm, WIIMOTE_LED_NONE);
break;
}
case 1:
{
struct read_req_t* req = wm->read_req;
struct accel_t* accel = &wm->accel_calib;
byte val;
/* received read data */
accel->cal_zero.x = req->buf[0];
accel->cal_zero.y = req->buf[1];
accel->cal_zero.z = req->buf[2];
accel->cal_g.x = req->buf[4] - accel->cal_zero.x;
accel->cal_g.y = req->buf[5] - accel->cal_zero.y;
accel->cal_g.z = req->buf[6] - accel->cal_zero.z;
/* done with the buffer */
free(req->buf);
/* handshake is done */
WIIUSE_DEBUG("Handshake finished. Calibration: Idle: X=%x Y=%x Z=%x\t+1g: X=%x Y=%x Z=%x",
accel->cal_zero.x, accel->cal_zero.y, accel->cal_zero.z,
accel->cal_g.x, accel->cal_g.y, accel->cal_g.z);
/* M+ off */
val = 0x55;
wiiuse_write_data_cb(wm, WM_EXP_MEM_ENABLE1, &val, 1, wiiuse_disable_motion_plus1);
break;
}
case 2:
{
/* request the status of the wiimote to check for any expansion */
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_HANDSHAKE);
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_HANDSHAKE_COMPLETE);
wm->handshake_state++;
/* now enable IR if it was set before the handshake completed */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) {
WIIUSE_DEBUG("Handshake finished, enabling IR.");
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_IR); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_IR);
wiiuse_set_ir(wm, 1); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_RUMBLE);
WIIMOTE_DISABLE_FLAG(wm, WIIUSE_CONTINUOUS);
wiiuse_set_report_type(wm);
/* send request to wiimote for accelerometer calibration */
buf = (byte*)malloc(sizeof(byte) * 8);
wiiuse_read_data_cb(wm, wiiuse_handshake, buf, WM_MEM_OFFSET_CALIBRATION, 7);
wm->handshake_state++;
wiiuse_set_leds(wm, WIIMOTE_LED_NONE);
break;
} }
wm->event = WIIUSE_CONNECT; case 1: {
wiiuse_status(wm); struct read_req_t* req = wm->read_req;
struct accel_t* accel = &wm->accel_calib;
byte val;
break; /* received read data */
} accel->cal_zero.x = req->buf[0];
accel->cal_zero.y = req->buf[1];
accel->cal_zero.z = req->buf[2];
default: accel->cal_g.x = req->buf[4] - accel->cal_zero.x;
{ accel->cal_g.y = req->buf[5] - accel->cal_zero.y;
break; accel->cal_g.z = req->buf[6] - accel->cal_zero.z;
}
/* done with the buffer */
free(req->buf);
/* handshake is done */
WIIUSE_DEBUG("Handshake finished. Calibration: Idle: X=%x Y=%x Z=%x\t+1g: X=%x Y=%x Z=%x",
accel->cal_zero.x, accel->cal_zero.y, accel->cal_zero.z,
accel->cal_g.x, accel->cal_g.y, accel->cal_g.z);
/* M+ off */
val = 0x55;
wiiuse_write_data_cb(wm, WM_EXP_MEM_ENABLE1, &val, 1, wiiuse_disable_motion_plus1);
break;
}
case 2: {
/* request the status of the wiimote to check for any expansion */
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_HANDSHAKE);
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_HANDSHAKE_COMPLETE);
wm->handshake_state++;
/* now enable IR if it was set before the handshake completed */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) {
WIIUSE_DEBUG("Handshake finished, enabling IR.");
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_IR);
wiiuse_set_ir(wm, 1);
}
wm->event = WIIUSE_CONNECT;
wiiuse_status(wm);
break;
}
default: {
break;
}
} }
} }
static void wiiuse_disable_motion_plus1(struct wiimote_t *wm,byte *data,unsigned short len) static void wiiuse_disable_motion_plus1(struct wiimote_t *wm, byte *data, unsigned short len) {
{
byte val = 0x00; byte val = 0x00;
wiiuse_write_data_cb(wm, WM_EXP_MEM_ENABLE1, &val, 1, wiiuse_disable_motion_plus2); wiiuse_write_data_cb(wm, WM_EXP_MEM_ENABLE1, &val, 1, wiiuse_disable_motion_plus2);
} }
static void wiiuse_disable_motion_plus2(struct wiimote_t *wm,byte *data,unsigned short len) static void wiiuse_disable_motion_plus2(struct wiimote_t *wm, byte *data, unsigned short len) {
{
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_FAILED); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_FAILED);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE);
wiiuse_set_ir_mode(wm); wiiuse_set_ir_mode(wm);

12
src/io.h
View File

@@ -40,13 +40,13 @@
extern "C" { extern "C" {
#endif #endif
/** @defgroup internal_io Internal: Device I/O */ /** @defgroup internal_io Internal: Device I/O */
/** @{ */ /** @{ */
void wiiuse_handshake(struct wiimote_t* wm, byte* data, uint16_t len); void wiiuse_handshake(struct wiimote_t* wm, byte* data, uint16_t len);
void wiiuse_wait_report(struct wiimote_t *wm, int report, byte *buffer, int bufferLength); void wiiuse_wait_report(struct wiimote_t *wm, int report, byte *buffer, int bufferLength);
void wiiuse_read_data_sync(struct wiimote_t *wm, byte memory, unsigned addr, unsigned short size, byte *data); void wiiuse_read_data_sync(struct wiimote_t *wm, byte memory, unsigned addr, unsigned short size, byte *data);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

389
src/ir.c
View File

@@ -57,16 +57,22 @@ static const byte WM_IR_BLOCK2_LEVEL4[] = "\x35\x03";
static const byte WM_IR_BLOCK1_LEVEL5[] = "\x07\x00\x00\x71\x01\x00\x72\x00\x20"; static const byte WM_IR_BLOCK1_LEVEL5[] = "\x07\x00\x00\x71\x01\x00\x72\x00\x20";
static const byte WM_IR_BLOCK2_LEVEL5[] = "\x1f\x03"; static const byte WM_IR_BLOCK2_LEVEL5[] = "\x1f\x03";
void wiiuse_set_ir_mode(struct wiimote_t *wm) void wiiuse_set_ir_mode(struct wiimote_t *wm) {
{
byte buf = 0x00; byte buf = 0x00;
if(!wm) return; if (!wm) {
if(!WIIMOTE_IS_SET(wm,WIIMOTE_STATE_IR)) return; return;
}
if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) {
return;
}
if(WIIMOTE_IS_SET(wm,WIIMOTE_STATE_EXP)) buf = WM_IR_TYPE_BASIC; if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP)) {
else buf = WM_IR_TYPE_EXTENDED; buf = WM_IR_TYPE_BASIC;
wiiuse_write_data(wm,WM_REG_IR_MODENUM, &buf, 1); } else {
buf = WM_IR_TYPE_EXTENDED;
}
wiiuse_write_data(wm, WM_REG_IR_MODENUM, &buf, 1);
} }
/** /**
* @brief Set if the wiimote should track IR targets. * @brief Set if the wiimote should track IR targets.
@@ -80,8 +86,9 @@ void wiiuse_set_ir(struct wiimote_t* wm, int status) {
const byte* block2 = NULL; const byte* block2 = NULL;
int ir_level; int ir_level;
if (!wm) if (!wm) {
return; return;
}
/* /*
* Wait for the handshake to finish first. * Wait for the handshake to finish first.
@@ -90,7 +97,7 @@ void wiiuse_set_ir(struct wiimote_t* wm, int status) {
* again to actually enable IR. * again to actually enable IR.
*/ */
if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_HANDSHAKE_COMPLETE)) { if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_HANDSHAKE_COMPLETE)) {
if(status) { if (status) {
WIIUSE_DEBUG("Tried to enable IR, will wait until handshake finishes."); WIIUSE_DEBUG("Tried to enable IR, will wait until handshake finishes.");
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_IR); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_IR);
} /* else ignoring request to turn off, since it's turned off by default */ } /* else ignoring request to turn off, since it's turned off by default */
@@ -108,13 +115,15 @@ void wiiuse_set_ir(struct wiimote_t* wm, int status) {
if (status) { if (status) {
/* if already enabled then stop */ /* if already enabled then stop */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) {
return; return;
}
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_IR); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_IR);
} else { } else {
/* if already disabled then stop */ /* if already disabled then stop */
if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) {
return; return;
}
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_IR); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_IR);
} }
@@ -141,10 +150,11 @@ void wiiuse_set_ir(struct wiimote_t* wm, int status) {
wiiuse_write_data(wm, WM_REG_IR_BLOCK2, (byte*)block2, 2); wiiuse_write_data(wm, WM_REG_IR_BLOCK2, (byte*)block2, 2);
/* set the IR mode */ /* set the IR mode */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP)) {
buf = WM_IR_TYPE_BASIC; buf = WM_IR_TYPE_BASIC;
else } else {
buf = WM_IR_TYPE_EXTENDED; buf = WM_IR_TYPE_EXTENDED;
}
wiiuse_write_data(wm, WM_REG_IR_MODENUM, &buf, 1); wiiuse_write_data(wm, WM_REG_IR_MODENUM, &buf, 1);
wiiuse_millisleep(50); wiiuse_millisleep(50);
@@ -201,10 +211,12 @@ static int get_ir_sens(struct wiimote_t* wm, const byte** block1, const byte** b
* @param status 1 to enable, 0 to disable. * @param status 1 to enable, 0 to disable.
*/ */
void wiiuse_set_ir_vres(struct wiimote_t* wm, unsigned int x, unsigned int y) { void wiiuse_set_ir_vres(struct wiimote_t* wm, unsigned int x, unsigned int y) {
if (!wm) return; if (!wm) {
return;
}
wm->ir.vres[0] = (x-1); wm->ir.vres[0] = (x - 1);
wm->ir.vres[1] = (y-1); wm->ir.vres[1] = (y - 1);
} }
@@ -214,7 +226,9 @@ void wiiuse_set_ir_vres(struct wiimote_t* wm, unsigned int x, unsigned int y) {
* @param wm Pointer to a wiimote_t structure. * @param wm Pointer to a wiimote_t structure.
*/ */
void wiiuse_set_ir_position(struct wiimote_t* wm, enum ir_position_t pos) { void wiiuse_set_ir_position(struct wiimote_t* wm, enum ir_position_t pos) {
if (!wm) return; if (!wm) {
return;
}
wm->ir.pos = pos; wm->ir.pos = pos;
@@ -223,20 +237,22 @@ void wiiuse_set_ir_position(struct wiimote_t* wm, enum ir_position_t pos) {
case WIIUSE_IR_ABOVE: case WIIUSE_IR_ABOVE:
wm->ir.offset[0] = 0; wm->ir.offset[0] = 0;
if (wm->ir.aspect == WIIUSE_ASPECT_16_9) if (wm->ir.aspect == WIIUSE_ASPECT_16_9) {
wm->ir.offset[1] = WM_ASPECT_16_9_Y/2 - 70; wm->ir.offset[1] = WM_ASPECT_16_9_Y / 2 - 70;
else if (wm->ir.aspect == WIIUSE_ASPECT_4_3) } else if (wm->ir.aspect == WIIUSE_ASPECT_4_3) {
wm->ir.offset[1] = WM_ASPECT_4_3_Y/2 - 100; wm->ir.offset[1] = WM_ASPECT_4_3_Y / 2 - 100;
}
return; return;
case WIIUSE_IR_BELOW: case WIIUSE_IR_BELOW:
wm->ir.offset[0] = 0; wm->ir.offset[0] = 0;
if (wm->ir.aspect == WIIUSE_ASPECT_16_9) if (wm->ir.aspect == WIIUSE_ASPECT_16_9) {
wm->ir.offset[1] = -WM_ASPECT_16_9_Y/2 + 100; wm->ir.offset[1] = -WM_ASPECT_16_9_Y / 2 + 100;
else if (wm->ir.aspect == WIIUSE_ASPECT_4_3) } else if (wm->ir.aspect == WIIUSE_ASPECT_4_3) {
wm->ir.offset[1] = -WM_ASPECT_4_3_Y/2 + 70; wm->ir.offset[1] = -WM_ASPECT_4_3_Y / 2 + 70;
}
return; return;
@@ -253,7 +269,9 @@ void wiiuse_set_ir_position(struct wiimote_t* wm, enum ir_position_t pos) {
* @param aspect Either WIIUSE_ASPECT_16_9 or WIIUSE_ASPECT_4_3 * @param aspect Either WIIUSE_ASPECT_16_9 or WIIUSE_ASPECT_4_3
*/ */
void wiiuse_set_aspect_ratio(struct wiimote_t* wm, enum aspect_t aspect) { void wiiuse_set_aspect_ratio(struct wiimote_t* wm, enum aspect_t aspect) {
if (!wm) return; if (!wm) {
return;
}
wm->ir.aspect = aspect; wm->ir.aspect = aspect;
@@ -283,16 +301,22 @@ void wiiuse_set_ir_sensitivity(struct wiimote_t* wm, int level) {
const byte* block1 = NULL; const byte* block1 = NULL;
const byte* block2 = NULL; const byte* block2 = NULL;
if (!wm) return; if (!wm) {
return;
}
if (level > 5) level = 5; if (level > 5) {
if (level < 1) level = 1; level = 5;
}
if (level < 1) {
level = 1;
}
WIIMOTE_DISABLE_STATE(wm, (WIIMOTE_STATE_IR_SENS_LVL1 | WIIMOTE_DISABLE_STATE(wm, (WIIMOTE_STATE_IR_SENS_LVL1 |
WIIMOTE_STATE_IR_SENS_LVL2 | WIIMOTE_STATE_IR_SENS_LVL2 |
WIIMOTE_STATE_IR_SENS_LVL3 | WIIMOTE_STATE_IR_SENS_LVL3 |
WIIMOTE_STATE_IR_SENS_LVL4 | WIIMOTE_STATE_IR_SENS_LVL4 |
WIIMOTE_STATE_IR_SENS_LVL5)); WIIMOTE_STATE_IR_SENS_LVL5));
switch (level) { switch (level) {
case 1: case 1:
@@ -348,9 +372,9 @@ void calculate_basic_ir(struct wiimote_t* wm, byte* data) {
/* set each IR spot to visible if spot is in range */ /* set each IR spot to visible if spot is in range */
for (i = 0; i < 4; ++i) { for (i = 0; i < 4; ++i) {
if (dot[i].ry == 1023) if (dot[i].ry == 1023) {
dot[i].visible = 0; dot[i].visible = 0;
else { } else {
dot[i].visible = 1; dot[i].visible = 1;
dot[i].size = 0; /* since we don't know the size, set it as 0 */ dot[i].size = 0; /* since we don't know the size, set it as 0 */
} }
@@ -371,16 +395,17 @@ void calculate_extended_ir(struct wiimote_t* wm, byte* data) {
int i; int i;
for (i = 0; i < 4; ++i) { for (i = 0; i < 4; ++i) {
dot[i].rx = 1023 - (data[3*i] | ((data[(3*i)+2] & 0x30) << 4)); dot[i].rx = 1023 - (data[3 * i] | ((data[(3 * i) + 2] & 0x30) << 4));
dot[i].ry = data[(3*i)+1] | ((data[(3*i)+2] & 0xC0) << 2); dot[i].ry = data[(3 * i) + 1] | ((data[(3 * i) + 2] & 0xC0) << 2);
dot[i].size = data[(3*i)+2] & 0x0F; dot[i].size = data[(3 * i) + 2] & 0x0F;
/* if in range set to visible */ /* if in range set to visible */
if (dot[i].ry == 1023) if (dot[i].ry == 1023) {
dot[i].visible = 0; dot[i].visible = 0;
else } else {
dot[i].visible = 1; dot[i].visible = 1;
}
} }
interpret_ir_data(wm); interpret_ir_data(wm);
@@ -398,147 +423,150 @@ static void interpret_ir_data(struct wiimote_t* wm) {
float roll = 0.0f; float roll = 0.0f;
int last_num_dots = wm->ir.num_dots; int last_num_dots = wm->ir.num_dots;
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_ACC)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_ACC)) {
roll = wm->orient.roll; roll = wm->orient.roll;
}
/* count visible dots */ /* count visible dots */
wm->ir.num_dots = 0; wm->ir.num_dots = 0;
for (i = 0; i < 4; ++i) { for (i = 0; i < 4; ++i) {
if (dot[i].visible) if (dot[i].visible) {
wm->ir.num_dots++; wm->ir.num_dots++;
}
} }
switch (wm->ir.num_dots) { switch (wm->ir.num_dots) {
case 0: case 0: {
{ wm->ir.state = 0;
wm->ir.state = 0;
/* reset the dot ordering */ /* reset the dot ordering */
for (i = 0; i < 4; ++i)
dot[i].order = 0;
wm->ir.x = 0;
wm->ir.y = 0;
wm->ir.z = 0.0f;
return;
}
case 1:
{
fix_rotated_ir_dots(wm->ir.dot, roll);
if (wm->ir.state < 2) {
/*
* Only 1 known dot, so use just that.
*/
for (i = 0; i < 4; ++i) { for (i = 0; i < 4; ++i) {
if (dot[i].visible) { dot[i].order = 0;
wm->ir.x = dot[i].x;
wm->ir.y = dot[i].y;
wm->ir.ax = wm->ir.x;
wm->ir.ay = wm->ir.y;
/* can't calculate yaw because we don't have the distance */
/* wm->orient.yaw = calc_yaw(&wm->ir); */
ir_convert_to_vres(&wm->ir.x, &wm->ir.y, wm->ir.aspect, wm->ir.vres[0], wm->ir.vres[1]);
break;
}
} }
} else {
/*
* Only see 1 dot but know theres 2.
* Try to estimate where the other one
* should be and use that.
*/
for (i = 0; i < 4; ++i) {
if (dot[i].visible) {
int ox = 0;
int x, y;
if (dot[i].order == 1)
/* visible is the left dot - estimate where the right is */
ox = (int32_t)(dot[i].x + wm->ir.distance);
else if (dot[i].order == 2)
/* visible is the right dot - estimate where the left is */
ox = (int32_t)(dot[i].x - wm->ir.distance);
x = ((signed int)dot[i].x + ox) / 2;
y = dot[i].y;
wm->ir.ax = x;
wm->ir.ay = y;
wm->orient.yaw = calc_yaw(&wm->ir);
if (ir_correct_for_bounds(&x, &y, wm->ir.aspect, wm->ir.offset[0], wm->ir.offset[1])) {
ir_convert_to_vres(&x, &y, wm->ir.aspect, wm->ir.vres[0], wm->ir.vres[1]);
wm->ir.x = x;
wm->ir.y = y;
}
break;
}
}
}
break;
}
case 2:
case 3:
case 4:
{
/*
* Two (or more) dots known and seen.
* Average them together to estimate the true location.
*/
int x, y;
wm->ir.state = 2;
fix_rotated_ir_dots(wm->ir.dot, roll);
/* if there is at least 1 new dot, reorder them all */
if (wm->ir.num_dots > last_num_dots) {
reorder_ir_dots(dot);
wm->ir.x = 0; wm->ir.x = 0;
wm->ir.y = 0; wm->ir.y = 0;
wm->ir.z = 0.0f;
return;
} }
case 1: {
fix_rotated_ir_dots(wm->ir.dot, roll);
wm->ir.distance = ir_distance(dot); if (wm->ir.state < 2) {
wm->ir.z = 1023 - wm->ir.distance; /*
* Only 1 known dot, so use just that.
*/
for (i = 0; i < 4; ++i) {
if (dot[i].visible) {
wm->ir.x = dot[i].x;
wm->ir.y = dot[i].y;
get_ir_dot_avg(wm->ir.dot, &x, &y); wm->ir.ax = wm->ir.x;
wm->ir.ay = wm->ir.y;
wm->ir.ax = x; /* can't calculate yaw because we don't have the distance */
wm->ir.ay = y; /* wm->orient.yaw = calc_yaw(&wm->ir); */
wm->orient.yaw = calc_yaw(&wm->ir);
if (ir_correct_for_bounds(&x, &y, wm->ir.aspect, wm->ir.offset[0], wm->ir.offset[1])) { ir_convert_to_vres(&wm->ir.x, &wm->ir.y, wm->ir.aspect, wm->ir.vres[0], wm->ir.vres[1]);
ir_convert_to_vres(&x, &y, wm->ir.aspect, wm->ir.vres[0], wm->ir.vres[1]); break;
wm->ir.x = x; }
wm->ir.y = y; }
} else {
/*
* Only see 1 dot but know theres 2.
* Try to estimate where the other one
* should be and use that.
*/
for (i = 0; i < 4; ++i) {
if (dot[i].visible) {
int ox = 0;
int x, y;
if (dot[i].order == 1)
/* visible is the left dot - estimate where the right is */
{
ox = (int32_t)(dot[i].x + wm->ir.distance);
} else if (dot[i].order == 2)
/* visible is the right dot - estimate where the left is */
{
ox = (int32_t)(dot[i].x - wm->ir.distance);
}
x = ((signed int)dot[i].x + ox) / 2;
y = dot[i].y;
wm->ir.ax = x;
wm->ir.ay = y;
wm->orient.yaw = calc_yaw(&wm->ir);
if (ir_correct_for_bounds(&x, &y, wm->ir.aspect, wm->ir.offset[0], wm->ir.offset[1])) {
ir_convert_to_vres(&x, &y, wm->ir.aspect, wm->ir.vres[0], wm->ir.vres[1]);
wm->ir.x = x;
wm->ir.y = y;
}
break;
}
}
}
break;
} }
case 2:
case 3:
case 4: {
/*
* Two (or more) dots known and seen.
* Average them together to estimate the true location.
*/
int x, y;
wm->ir.state = 2;
break; fix_rotated_ir_dots(wm->ir.dot, roll);
}
default: /* if there is at least 1 new dot, reorder them all */
{ if (wm->ir.num_dots > last_num_dots) {
break; reorder_ir_dots(dot);
} wm->ir.x = 0;
wm->ir.y = 0;
}
wm->ir.distance = ir_distance(dot);
wm->ir.z = 1023 - wm->ir.distance;
get_ir_dot_avg(wm->ir.dot, &x, &y);
wm->ir.ax = x;
wm->ir.ay = y;
wm->orient.yaw = calc_yaw(&wm->ir);
if (ir_correct_for_bounds(&x, &y, wm->ir.aspect, wm->ir.offset[0], wm->ir.offset[1])) {
ir_convert_to_vres(&x, &y, wm->ir.aspect, wm->ir.vres[0], wm->ir.vres[1]);
wm->ir.x = x;
wm->ir.y = y;
}
break;
}
default: {
break;
}
} }
#ifdef WITH_WIIUSE_DEBUG #ifdef WITH_WIIUSE_DEBUG
{ {
int ir_level; int ir_level;
WIIUSE_GET_IR_SENSITIVITY(wm, &ir_level); WIIUSE_GET_IR_SENSITIVITY(wm, &ir_level);
WIIUSE_DEBUG("IR sensitivity: %i", ir_level); WIIUSE_DEBUG("IR sensitivity: %i", ir_level);
WIIUSE_DEBUG("IR visible dots: %i", wm->ir.num_dots); WIIUSE_DEBUG("IR visible dots: %i", wm->ir.num_dots);
for (i = 0; i < 4; ++i) for (i = 0; i < 4; ++i)
if (dot[i].visible) if (dot[i].visible) {
WIIUSE_DEBUG("IR[%i][order %i] (%.3i, %.3i) -> (%.3i, %.3i)", i, dot[i].order, dot[i].rx, dot[i].ry, dot[i].x, dot[i].y); WIIUSE_DEBUG("IR[%i][order %i] (%.3i, %.3i) -> (%.3i, %.3i)", i, dot[i].order, dot[i].rx, dot[i].ry, dot[i].x, dot[i].y);
WIIUSE_DEBUG("IR[absolute]: (%i, %i)", wm->ir.x, wm->ir.y); }
WIIUSE_DEBUG("IR[absolute]: (%i, %i)", wm->ir.x, wm->ir.y);
} }
#endif #endif
} }
@@ -579,17 +607,18 @@ static void fix_rotated_ir_dots(struct ir_dot_t* dot, float ang) {
*/ */
for (i = 0; i < 4; ++i) { for (i = 0; i < 4; ++i) {
if (!dot[i].visible) if (!dot[i].visible) {
continue; continue;
}
x = dot[i].rx - (1024/2); x = dot[i].rx - (1024 / 2);
y = dot[i].ry - (768/2); y = dot[i].ry - (768 / 2);
dot[i].x = (uint32_t)((c * x) + (-s * y)); dot[i].x = (uint32_t)((c * x) + (-s * y));
dot[i].y = (uint32_t)((s * x) + (c * y)); dot[i].y = (uint32_t)((s * x) + (c * y));
dot[i].x += (1024/2); dot[i].x += (1024 / 2);
dot[i].y += (768/2); dot[i].y += (768 / 2);
} }
} }
@@ -629,19 +658,22 @@ static void reorder_ir_dots(struct ir_dot_t* dot) {
int i, j, order; int i, j, order;
/* reset the dot ordering */ /* reset the dot ordering */
for (i = 0; i < 4; ++i) for (i = 0; i < 4; ++i) {
dot[i].order = 0; dot[i].order = 0;
}
for (order = 1; order < 5; ++order) { for (order = 1; order < 5; ++order) {
i = 0; i = 0;
for (; !dot[i].visible || dot[i].order; ++i) for (; !dot[i].visible || dot[i].order; ++i)
if (i >= 3) if (i >= 3) {
return; return;
}
for (j = 0; j < 4; ++j) { for (j = 0; j < 4; ++j) {
if (dot[j].visible && !dot[j].order && (dot[j].x < dot[i].x)) if (dot[j].visible && !dot[j].order && (dot[j].x < dot[i].x)) {
i = j; i = j;
}
} }
dot[i].order = order; dot[i].order = order;
@@ -659,21 +691,25 @@ static float ir_distance(struct ir_dot_t* dot) {
int xd, yd; int xd, yd;
for (i1 = 0; i1 < 4; ++i1) for (i1 = 0; i1 < 4; ++i1)
if (dot[i1].visible) if (dot[i1].visible) {
break; break;
if (i1 == 4) }
if (i1 == 4) {
return 0.0f; return 0.0f;
}
for (i2 = i1+1; i2 < 4; ++i2) for (i2 = i1 + 1; i2 < 4; ++i2)
if (dot[i2].visible) if (dot[i2].visible) {
break; break;
if (i2 == 4) }
if (i2 == 4) {
return 0.0f; return 0.0f;
}
xd = dot[i2].x - dot[i1].x; xd = dot[i2].x - dot[i1].x;
yd = dot[i2].y - dot[i1].y; yd = dot[i2].y - dot[i1].y;
return sqrtf(xd*xd + yd*yd); return sqrtf(xd * xd + yd * yd);
} }
@@ -707,10 +743,9 @@ static int ir_correct_for_bounds(int* x, int* y, enum aspect_t aspect, int offse
y0 = ((768 - ys) / 2) + offset_y; y0 = ((768 - ys) / 2) + offset_y;
if ((*x >= x0) if ((*x >= x0)
&& (*x <= (x0 + xs)) && (*x <= (x0 + xs))
&& (*y >= y0) && (*y >= y0)
&& (*y <= (y0 + ys))) && (*y <= (y0 + ys))) {
{
*x -= offset_x; *x -= offset_x;
*y -= offset_y; *y -= offset_y;
@@ -735,8 +770,8 @@ static void ir_convert_to_vres(int* x, int* y, enum aspect_t aspect, int vx, int
ys = WM_ASPECT_4_3_Y; ys = WM_ASPECT_4_3_Y;
} }
*x -= ((1024-xs)/2); *x -= ((1024 - xs) / 2);
*y -= ((768-ys)/2); *y -= ((768 - ys) / 2);
*x = (int)((*x / (float)xs) * vx); *x = (int)((*x / (float)xs) * vx);
*y = (int)((*y / (float)ys) * vy); *y = (int)((*y / (float)ys) * vy);
@@ -754,5 +789,5 @@ float calc_yaw(struct ir_t* ir) {
x = (float)(ir->ax - 512); x = (float)(ir->ax - 512);
x = x * (ir->z / 1024.0f); x = x * (ir->z / 1024.0f);
return RAD_TO_DEGREE( atanf(x / ir->z) ); return RAD_TO_DEGREE(atanf(x / ir->z));
} }

14
src/ir.h
View File

@@ -44,13 +44,13 @@ extern "C" {
#endif #endif
/** @defgroup internal_ir Internal: IR Sensor */ /** @defgroup internal_ir Internal: IR Sensor */
/** @{ */ /** @{ */
void wiiuse_set_ir_mode(struct wiimote_t *wm); void wiiuse_set_ir_mode(struct wiimote_t *wm);
void calculate_basic_ir(struct wiimote_t* wm, byte* data); void calculate_basic_ir(struct wiimote_t* wm, byte* data);
void calculate_extended_ir(struct wiimote_t* wm, byte* data); void calculate_extended_ir(struct wiimote_t* wm, byte* data);
float calc_yaw(struct ir_t* ir); float calc_yaw(struct ir_t* ir);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

216
src/motion_plus.c
View File

@@ -43,92 +43,83 @@ static void wiiuse_calibrate_motion_plus(struct motion_plus_t *mp);
static void calculate_gyro_rates(struct motion_plus_t* mp); static void calculate_gyro_rates(struct motion_plus_t* mp);
void wiiuse_probe_motion_plus(struct wiimote_t *wm) void wiiuse_probe_motion_plus(struct wiimote_t *wm) {
{ byte buf[MAX_PAYLOAD];
byte buf[MAX_PAYLOAD]; unsigned id;
unsigned id;
wiiuse_read_data_sync(wm, 0, WM_EXP_MOTION_PLUS_IDENT, 6, buf); wiiuse_read_data_sync(wm, 0, WM_EXP_MOTION_PLUS_IDENT, 6, buf);
/* check error code */ /* check error code */
if(buf[4] & 0x0f) if (buf[4] & 0x0f) {
{ WIIUSE_DEBUG("No Motion+ available, stopping probe.");
WIIUSE_DEBUG("No Motion+ available, stopping probe."); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_MPLUS_PRESENT);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_MPLUS_PRESENT); return;
return; }
}
/* decode the id */ /* decode the id */
id = from_big_endian_uint32_t(buf + 2); id = from_big_endian_uint32_t(buf + 2);
if(id != EXP_ID_CODE_INACTIVE_MOTION_PLUS && if (id != EXP_ID_CODE_INACTIVE_MOTION_PLUS &&
id != EXP_ID_CODE_NLA_MOTION_PLUS && id != EXP_ID_CODE_NLA_MOTION_PLUS &&
id != EXP_ID_CODE_NLA_MOTION_PLUS_NUNCHUK && id != EXP_ID_CODE_NLA_MOTION_PLUS_NUNCHUK &&
id != EXP_ID_CODE_NLA_MOTION_PLUS_CLASSIC) id != EXP_ID_CODE_NLA_MOTION_PLUS_CLASSIC) {
{ /* we have read something weird */
/* we have read something weird */ WIIUSE_DEBUG("Motion+ ID doesn't match, probably not connected.");
WIIUSE_DEBUG("Motion+ ID doesn't match, probably not connected."); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_MPLUS_PRESENT);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_MPLUS_PRESENT); return;
return; }
}
WIIUSE_DEBUG("Detected inactive Motion+!"); WIIUSE_DEBUG("Detected inactive Motion+!");
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_MPLUS_PRESENT); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_MPLUS_PRESENT);
/* init M+ */ /* init M+ */
buf[0] = 0x55; buf[0] = 0x55;
wiiuse_write_data(wm, WM_EXP_MOTION_PLUS_INIT, buf, 1); wiiuse_write_data(wm, WM_EXP_MOTION_PLUS_INIT, buf, 1);
/* Init whatever is hanging on the pass-through port */ /* Init whatever is hanging on the pass-through port */
buf[0] = 0x55; buf[0] = 0x55;
wiiuse_write_data(wm, WM_EXP_MEM_ENABLE1, buf, 1); wiiuse_write_data(wm, WM_EXP_MEM_ENABLE1, buf, 1);
buf[0] = 0x00; buf[0] = 0x00;
wiiuse_write_data(wm, WM_EXP_MEM_ENABLE2, buf, 1); wiiuse_write_data(wm, WM_EXP_MEM_ENABLE2, buf, 1);
/* Init gyroscope data */ /* Init gyroscope data */
wm->exp.mp.cal_gyro.roll = 0; wm->exp.mp.cal_gyro.roll = 0;
wm->exp.mp.cal_gyro.pitch = 0; wm->exp.mp.cal_gyro.pitch = 0;
wm->exp.mp.cal_gyro.yaw = 0; wm->exp.mp.cal_gyro.yaw = 0;
wm->exp.mp.orient.roll = 0.0; wm->exp.mp.orient.roll = 0.0;
wm->exp.mp.orient.pitch = 0.0; wm->exp.mp.orient.pitch = 0.0;
wm->exp.mp.orient.yaw = 0.0; wm->exp.mp.orient.yaw = 0.0;
wm->exp.mp.raw_gyro_threshold = 10; wm->exp.mp.raw_gyro_threshold = 10;
wm->exp.mp.nc = &(wm->exp.nunchuk); wm->exp.mp.nc = &(wm->exp.nunchuk);
wm->exp.mp.classic = &(wm->exp.classic); wm->exp.mp.classic = &(wm->exp.classic);
wm->exp.nunchuk.flags = &wm->flags; wm->exp.nunchuk.flags = &wm->flags;
wm->exp.mp.ext = 0; wm->exp.mp.ext = 0;
wiiuse_set_ir_mode(wm); wiiuse_set_ir_mode(wm);
wiiuse_set_report_type(wm); wiiuse_set_report_type(wm);
} }
void wiiuse_motion_plus_handshake(struct wiimote_t *wm,byte *data,unsigned short len) void wiiuse_motion_plus_handshake(struct wiimote_t *wm, byte *data, unsigned short len) {
{
uint32_t val; uint32_t val;
if(data == NULL) if (data == NULL) {
{
wiiuse_read_data_cb(wm, wiiuse_motion_plus_handshake, wm->motion_plus_id, WM_EXP_ID, 6); wiiuse_read_data_cb(wm, wiiuse_motion_plus_handshake, wm->motion_plus_id, WM_EXP_ID, 6);
} } else {
else
{
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_FAILED); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_FAILED);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE);
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_EXP); /* tell wiimote to include exp. data in reports */ WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_EXP); /* tell wiimote to include exp. data in reports */
val = from_big_endian_uint32_t(data + 2); val = from_big_endian_uint32_t(data + 2);
if(val == EXP_ID_CODE_MOTION_PLUS || if (val == EXP_ID_CODE_MOTION_PLUS ||
val == EXP_ID_CODE_MOTION_PLUS_NUNCHUK || val == EXP_ID_CODE_MOTION_PLUS_NUNCHUK ||
val == EXP_ID_CODE_MOTION_PLUS_CLASSIC) val == EXP_ID_CODE_MOTION_PLUS_CLASSIC) {
{
/* handshake done */ /* handshake done */
wm->event = WIIUSE_MOTION_PLUS_ACTIVATED; wm->event = WIIUSE_MOTION_PLUS_ACTIVATED;
switch(val) switch (val) {
{
case EXP_ID_CODE_MOTION_PLUS: case EXP_ID_CODE_MOTION_PLUS:
wm->exp.type = EXP_MOTION_PLUS; wm->exp.type = EXP_MOTION_PLUS;
break; break;
@@ -171,16 +162,14 @@ void wiiuse_motion_plus_handshake(struct wiimote_t *wm,byte *data,unsigned short
} }
} }
static void wiiuse_set_motion_plus_clear2(struct wiimote_t *wm,byte *data,unsigned short len) static void wiiuse_set_motion_plus_clear2(struct wiimote_t *wm, byte *data, unsigned short len) {
{
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_FAILED); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_FAILED);
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE);
wiiuse_set_ir_mode(wm); wiiuse_set_ir_mode(wm);
wiiuse_status(wm); wiiuse_status(wm);
} }
static void wiiuse_set_motion_plus_clear1(struct wiimote_t *wm,byte *data,unsigned short len) static void wiiuse_set_motion_plus_clear1(struct wiimote_t *wm, byte *data, unsigned short len) {
{
byte val = 0x00; byte val = 0x00;
wiiuse_write_data_cb(wm, WM_EXP_MEM_ENABLE1, &val, 1, wiiuse_set_motion_plus_clear2); wiiuse_write_data_cb(wm, WM_EXP_MEM_ENABLE1, &val, 1, wiiuse_set_motion_plus_clear2);
} }
@@ -188,40 +177,35 @@ static void wiiuse_set_motion_plus_clear1(struct wiimote_t *wm,byte *data,unsign
/** /**
* @brief Enable/disable Motion+ expansion * @brief Enable/disable Motion+ expansion
* *
* @param wm Pointer to the wiimote with Motion+ * @param wm Pointer to the wiimote with Motion+
* @param status 0 - off, 1 - on, standalone, 2 - nunchuk pass-through * @param status 0 - off, 1 - on, standalone, 2 - nunchuk pass-through
* *
*/ */
void wiiuse_set_motion_plus(struct wiimote_t *wm, int status) void wiiuse_set_motion_plus(struct wiimote_t *wm, int status) {
{
byte val; byte val;
if(!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_MPLUS_PRESENT) || if (!WIIMOTE_IS_SET(wm, WIIMOTE_STATE_MPLUS_PRESENT) ||
WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP_HANDSHAKE)) WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP_HANDSHAKE)) {
return; return;
}
if(status) if (status) {
{
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_EXP_HANDSHAKE);
val = (status == 1) ? 0x04 : 0x05; val = (status == 1) ? 0x04 : 0x05;
wiiuse_write_data_cb(wm, WM_EXP_MOTION_PLUS_ENABLE, &val, 1, wiiuse_motion_plus_handshake); wiiuse_write_data_cb(wm, WM_EXP_MOTION_PLUS_ENABLE, &val, 1, wiiuse_motion_plus_handshake);
} } else {
else
{
disable_expansion(wm); disable_expansion(wm);
val = 0x55; val = 0x55;
wiiuse_write_data_cb(wm, WM_EXP_MEM_ENABLE1, &val, 1, wiiuse_set_motion_plus_clear1); wiiuse_write_data_cb(wm, WM_EXP_MEM_ENABLE1, &val, 1, wiiuse_set_motion_plus_clear1);
} }
} }
void motion_plus_disconnected(struct motion_plus_t* mp) void motion_plus_disconnected(struct motion_plus_t* mp) {
{
WIIUSE_DEBUG("Motion plus disconnected"); WIIUSE_DEBUG("Motion plus disconnected");
memset(mp, 0, sizeof(struct motion_plus_t)); memset(mp, 0, sizeof(struct motion_plus_t));
} }
void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg) void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg) {
{
/* /*
* Pass-through modes interleave data from the gyro * Pass-through modes interleave data from the gyro
* with the expansion data. This extracts the tag * with the expansion data. This extracts the tag
@@ -230,8 +214,7 @@ void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg)
int isMPFrame = (1 << 1) & msg[5]; int isMPFrame = (1 << 1) & msg[5];
mp->ext = msg[4] & 0x1; /* extension attached to pass-through port? */ mp->ext = msg[4] & 0x1; /* extension attached to pass-through port? */
if (mp->ext == 0 || isMPFrame) /* reading gyro frame */ if (mp->ext == 0 || isMPFrame) { /* reading gyro frame */
{
/* Check if the gyroscope is in fast or slow mode (0 if rotating fast, 1 if slow or still) */ /* Check if the gyroscope is in fast or slow mode (0 if rotating fast, 1 if slow or still) */
mp->acc_mode = ((msg[4] & 0x2) << 1) | ((msg[3] & 0x1) << 1) | ((msg[3] & 0x2) >> 1); mp->acc_mode = ((msg[4] & 0x2) << 1) | ((msg[3] & 0x1) << 1) | ((msg[3] & 0x2) >> 1);
@@ -241,15 +224,14 @@ void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg)
/* First calibration */ /* First calibration */
if ((mp->raw_gyro.roll > 5000) && if ((mp->raw_gyro.roll > 5000) &&
(mp->raw_gyro.pitch > 5000) && (mp->raw_gyro.pitch > 5000) &&
(mp->raw_gyro.yaw > 5000) && (mp->raw_gyro.yaw > 5000) &&
(mp->raw_gyro.roll < 0x3fff) && (mp->raw_gyro.roll < 0x3fff) &&
(mp->raw_gyro.pitch < 0x3fff) && (mp->raw_gyro.pitch < 0x3fff) &&
(mp->raw_gyro.yaw < 0x3fff) && (mp->raw_gyro.yaw < 0x3fff) &&
!(mp->cal_gyro.roll) && !(mp->cal_gyro.roll) &&
!(mp->cal_gyro.pitch) && !(mp->cal_gyro.pitch) &&
!(mp->cal_gyro.yaw)) !(mp->cal_gyro.yaw)) {
{
wiiuse_calibrate_motion_plus(mp); wiiuse_calibrate_motion_plus(mp);
} }
@@ -257,11 +239,9 @@ void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg)
calculate_gyro_rates(mp); calculate_gyro_rates(mp);
} }
else else {
{
/* expansion frame */ /* expansion frame */
if (exp_type == EXP_MOTION_PLUS_NUNCHUK) if (exp_type == EXP_MOTION_PLUS_NUNCHUK) {
{
/* ok, this is nunchuck, re-encode it as regular nunchuck packet */ /* ok, this is nunchuck, re-encode it as regular nunchuck packet */
/* get button states */ /* get button states */
@@ -276,23 +256,21 @@ void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg)
mp->nc->accel.z = (msg[4] & 0xFE) | ((msg[5] >> 5) & 0x04); mp->nc->accel.z = (msg[4] & 0xFE) | ((msg[5] >> 5) & 0x04);
calculate_orientation(&(mp->nc->accel_calib), calculate_orientation(&(mp->nc->accel_calib),
&(mp->nc->accel), &(mp->nc->accel),
&(mp->nc->orient), &(mp->nc->orient),
NUNCHUK_IS_FLAG_SET(mp->nc, WIIUSE_SMOOTHING)); NUNCHUK_IS_FLAG_SET(mp->nc, WIIUSE_SMOOTHING));
calculate_gforce(&(mp->nc->accel_calib), calculate_gforce(&(mp->nc->accel_calib),
&(mp->nc->accel), &(mp->nc->accel),
&(mp->nc->gforce)); &(mp->nc->gforce));
} }
else if (exp_type == EXP_MOTION_PLUS_CLASSIC) else if (exp_type == EXP_MOTION_PLUS_CLASSIC) {
{
WIIUSE_ERROR("Classic controller pass-through is not implemented!\n"); WIIUSE_ERROR("Classic controller pass-through is not implemented!\n");
} }
else else {
{
WIIUSE_ERROR("Unsupported mode passed to motion_plus_event() !\n"); WIIUSE_ERROR("Unsupported mode passed to motion_plus_event() !\n");
} }
} }
@@ -306,8 +284,7 @@ void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg)
* This should be called only after receiving the first values * This should be called only after receiving the first values
* from the Motion Plus. * from the Motion Plus.
*/ */
void wiiuse_calibrate_motion_plus(struct motion_plus_t *mp) void wiiuse_calibrate_motion_plus(struct motion_plus_t *mp) {
{
mp->cal_gyro.roll = mp->raw_gyro.roll; mp->cal_gyro.roll = mp->raw_gyro.roll;
mp->cal_gyro.pitch = mp->raw_gyro.pitch; mp->cal_gyro.pitch = mp->raw_gyro.pitch;
mp->cal_gyro.yaw = mp->raw_gyro.yaw; mp->cal_gyro.yaw = mp->raw_gyro.yaw;
@@ -316,8 +293,7 @@ void wiiuse_calibrate_motion_plus(struct motion_plus_t *mp)
mp->orient.yaw = 0.0; mp->orient.yaw = 0.0;
} }
static void calculate_gyro_rates(struct motion_plus_t* mp) static void calculate_gyro_rates(struct motion_plus_t* mp) {
{
short int tmp_r, tmp_p, tmp_y; short int tmp_r, tmp_p, tmp_y;
float tmp_roll, tmp_pitch, tmp_yaw; float tmp_roll, tmp_pitch, tmp_yaw;
@@ -327,28 +303,34 @@ static void calculate_gyro_rates(struct motion_plus_t* mp)
tmp_y = mp->raw_gyro.yaw - mp->cal_gyro.yaw; tmp_y = mp->raw_gyro.yaw - mp->cal_gyro.yaw;
/* We convert to degree/sec according to fast/slow mode */ /* We convert to degree/sec according to fast/slow mode */
if (mp->acc_mode & 0x04) if (mp->acc_mode & 0x04) {
tmp_roll = (float)tmp_r / 20.0f; tmp_roll = (float)tmp_r / 20.0f;
else } else {
tmp_roll = (float)tmp_r / 4.0f; tmp_roll = (float)tmp_r / 4.0f;
}
if (mp->acc_mode & 0x02) if (mp->acc_mode & 0x02) {
tmp_pitch = (float)tmp_p / 20.0f; tmp_pitch = (float)tmp_p / 20.0f;
else } else {
tmp_pitch = (float)tmp_p / 4.0f; tmp_pitch = (float)tmp_p / 4.0f;
}
if (mp->acc_mode & 0x01) if (mp->acc_mode & 0x01) {
tmp_yaw = (float)tmp_y / 20.0f; tmp_yaw = (float)tmp_y / 20.0f;
else } else {
tmp_yaw = (float)tmp_y / 4.0f; tmp_yaw = (float)tmp_y / 4.0f;
}
/* Simple filtering */ /* Simple filtering */
if (fabs(tmp_roll) < 0.5f) if (fabs(tmp_roll) < 0.5f) {
tmp_roll = 0.0f; tmp_roll = 0.0f;
if (fabs(tmp_pitch) < 0.5f) }
if (fabs(tmp_pitch) < 0.5f) {
tmp_pitch = 0.0f; tmp_pitch = 0.0f;
if (fabs(tmp_yaw) < 0.5f) }
if (fabs(tmp_yaw) < 0.5f) {
tmp_yaw = 0.0f; tmp_yaw = 0.0f;
}
mp->angle_rate_gyro.roll = tmp_roll; mp->angle_rate_gyro.roll = tmp_roll;
mp->angle_rate_gyro.pitch = tmp_pitch; mp->angle_rate_gyro.pitch = tmp_pitch;

22
src/motion_plus.h
View File

@@ -27,10 +27,10 @@
* $Header$ * $Header$
* *
*/ */
/** /**
* @file * @file
* @brief Motion plus extension * @brief Motion plus extension
*/ */
#ifndef MOTION_PLUS_H_INCLUDED #ifndef MOTION_PLUS_H_INCLUDED
#define MOTION_PLUS_H_INCLUDED #define MOTION_PLUS_H_INCLUDED
@@ -41,17 +41,17 @@
extern "C" { extern "C" {
#endif #endif
/** @defgroup internal_mp Internal: MotionPlus */ /** @defgroup internal_mp Internal: MotionPlus */
/** @{ */ /** @{ */
void motion_plus_disconnected(struct motion_plus_t* mp); void motion_plus_disconnected(struct motion_plus_t* mp);
void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg); void motion_plus_event(struct motion_plus_t* mp, int exp_type, byte* msg);
void wiiuse_motion_plus_handshake(struct wiimote_t *wm, byte *data,unsigned short len); void wiiuse_motion_plus_handshake(struct wiimote_t *wm, byte *data, unsigned short len);
void wiiuse_probe_motion_plus(struct wiimote_t *wm); void wiiuse_probe_motion_plus(struct wiimote_t *wm);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

19
src/nunchuk.c
View File

@@ -77,8 +77,9 @@ int nunchuk_handshake(struct wiimote_t* wm, struct nunchuk_t* nc, byte* data, un
wiiuse_read_data_cb(wm, handshake_expansion, handshake_buf, WM_EXP_MEM_CALIBR, EXP_HANDSHAKE_LEN); wiiuse_read_data_cb(wm, handshake_expansion, handshake_buf, WM_EXP_MEM_CALIBR, EXP_HANDSHAKE_LEN);
return 0; return 0;
} else } else {
data += 16; data += 16;
}
} }
nc->accel_calib.cal_zero.x = data[0]; nc->accel_calib.cal_zero.x = data[0];
@@ -94,8 +95,8 @@ int nunchuk_handshake(struct wiimote_t* wm, struct nunchuk_t* nc, byte* data, un
nc->js.min.y = data[12]; nc->js.min.y = data[12];
nc->js.center.y = data[13]; nc->js.center.y = data[13];
WIIUSE_DEBUG("Nunchuk calibration X: min %x, max %x, center %x Y: min %x, max %x, center %x", WIIUSE_DEBUG("Nunchuk calibration X: min %x, max %x, center %x Y: min %x, max %x, center %x",
nc->js.min.x, nc->js.max.x, nc->js.center.x, nc->js.min.x, nc->js.max.x, nc->js.center.x,
nc->js.min.y, nc->js.max.y, nc->js.center.y); nc->js.min.y, nc->js.max.y, nc->js.center.y);
/* default the thresholds to the same as the wiimote */ /* default the thresholds to the same as the wiimote */
nc->orient_threshold = wm->orient_threshold; nc->orient_threshold = wm->orient_threshold;
@@ -104,9 +105,9 @@ int nunchuk_handshake(struct wiimote_t* wm, struct nunchuk_t* nc, byte* data, un
/* handshake done */ /* handshake done */
wm->exp.type = EXP_NUNCHUK; wm->exp.type = EXP_NUNCHUK;
#ifdef WIIUSE_WIN32 #ifdef WIIUSE_WIN32
wm->timeout = WIIMOTE_DEFAULT_TIMEOUT; wm->timeout = WIIMOTE_DEFAULT_TIMEOUT;
#endif #endif
return 1; return 1;
} }
@@ -177,7 +178,9 @@ void nunchuk_pressed_buttons(struct nunchuk_t* nc, byte now) {
* See wiiuse_set_orient_threshold() for details. * See wiiuse_set_orient_threshold() for details.
*/ */
void wiiuse_set_nunchuk_orient_threshold(struct wiimote_t* wm, float threshold) { void wiiuse_set_nunchuk_orient_threshold(struct wiimote_t* wm, float threshold) {
if (!wm) return; if (!wm) {
return;
}
wm->exp.nunchuk.orient_threshold = threshold; wm->exp.nunchuk.orient_threshold = threshold;
} }
@@ -192,7 +195,9 @@ void wiiuse_set_nunchuk_orient_threshold(struct wiimote_t* wm, float threshold)
* See wiiuse_set_orient_threshold() for details. * See wiiuse_set_orient_threshold() for details.
*/ */
void wiiuse_set_nunchuk_accel_threshold(struct wiimote_t* wm, int threshold) { void wiiuse_set_nunchuk_accel_threshold(struct wiimote_t* wm, int threshold) {
if (!wm) return; if (!wm) {
return;
}
wm->exp.nunchuk.accel_threshold = threshold; wm->exp.nunchuk.accel_threshold = threshold;
} }

14
src/nunchuk.h
View File

@@ -41,16 +41,16 @@ extern "C" {
#endif #endif
/** @defgroup internal_nunchuk Internal: Nunchuk */ /** @defgroup internal_nunchuk Internal: Nunchuk */
/** @{ */ /** @{ */
int nunchuk_handshake(struct wiimote_t* wm, struct nunchuk_t* nc, byte* data, unsigned short len); int nunchuk_handshake(struct wiimote_t* wm, struct nunchuk_t* nc, byte* data, unsigned short len);
void nunchuk_disconnected(struct nunchuk_t* nc); void nunchuk_disconnected(struct nunchuk_t* nc);
void nunchuk_event(struct nunchuk_t* nc, byte* msg); void nunchuk_event(struct nunchuk_t* nc, byte* msg);
void nunchuk_pressed_buttons(struct nunchuk_t* nc, byte now); void nunchuk_pressed_buttons(struct nunchuk_t* nc, byte now);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

24
src/os.h
View File

@@ -41,21 +41,21 @@ extern "C" {
#endif #endif
/** @defgroup internal_io Internal: Platform-specific Device I/O */ /** @defgroup internal_io Internal: Platform-specific Device I/O */
/** @{ */ /** @{ */
void wiiuse_init_platform_fields(struct wiimote_t* wm); void wiiuse_init_platform_fields(struct wiimote_t* wm);
void wiiuse_cleanup_platform_fields(struct wiimote_t* wm); void wiiuse_cleanup_platform_fields(struct wiimote_t* wm);
int wiiuse_os_find(struct wiimote_t** wm, int max_wiimotes, int timeout); int wiiuse_os_find(struct wiimote_t** wm, int max_wiimotes, int timeout);
int wiiuse_os_connect(struct wiimote_t** wm, int wiimotes); int wiiuse_os_connect(struct wiimote_t** wm, int wiimotes);
void wiiuse_os_disconnect(struct wiimote_t* wm); void wiiuse_os_disconnect(struct wiimote_t* wm);
int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes); int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes);
/* buf[0] will be the report type, buf+1 the rest of the report */ /* buf[0] will be the report type, buf+1 the rest of the report */
int wiiuse_os_read(struct wiimote_t* wm, byte* buf, int len); int wiiuse_os_read(struct wiimote_t* wm, byte* buf, int len);
int wiiuse_os_write(struct wiimote_t* wm, byte report_type, byte* buf, int len); int wiiuse_os_write(struct wiimote_t* wm, byte report_type, byte* buf, int len);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

52
src/os_nix.c
View File

@@ -99,9 +99,8 @@ int wiiuse_os_find(struct wiimote_t** wm, int max_wiimotes, int timeout) {
/* display discovered devices */ /* display discovered devices */
for (i = 0; (i < found_devices) && (found_wiimotes < max_wiimotes); ++i) { for (i = 0; (i < found_devices) && (found_wiimotes < max_wiimotes); ++i) {
if ((scan_info[i].dev_class[0] == WM_DEV_CLASS_0) && if ((scan_info[i].dev_class[0] == WM_DEV_CLASS_0) &&
(scan_info[i].dev_class[1] == WM_DEV_CLASS_1) && (scan_info[i].dev_class[1] == WM_DEV_CLASS_1) &&
(scan_info[i].dev_class[2] == WM_DEV_CLASS_2)) (scan_info[i].dev_class[2] == WM_DEV_CLASS_2)) {
{
/* found a device */ /* found a device */
ba2str(&scan_info[i].bdaddr, wm[found_wiimotes]->bdaddr_str); ba2str(&scan_info[i].bdaddr, wm[found_wiimotes]->bdaddr_str);
@@ -129,10 +128,13 @@ int wiiuse_os_connect(struct wiimote_t** wm, int wiimotes) {
for (; i < wiimotes; ++i) { for (; i < wiimotes; ++i) {
if (!WIIMOTE_IS_SET(wm[i], WIIMOTE_STATE_DEV_FOUND)) if (!WIIMOTE_IS_SET(wm[i], WIIMOTE_STATE_DEV_FOUND))
/* if the device address is not set, skip it */ /* if the device address is not set, skip it */
{
continue; continue;
}
if (wiiuse_os_connect_single(wm[i], NULL)) if (wiiuse_os_connect_single(wm[i], NULL)) {
++connected; ++connected;
}
} }
return connected; return connected;
@@ -150,18 +152,19 @@ int wiiuse_os_connect(struct wiimote_t** wm, int wiimotes) {
*/ */
static int wiiuse_os_connect_single(struct wiimote_t* wm, char* address) { static int wiiuse_os_connect_single(struct wiimote_t* wm, char* address) {
struct sockaddr_l2 addr; struct sockaddr_l2 addr;
memset(&addr, 0, sizeof (addr)); memset(&addr, 0, sizeof(addr));
if (!wm || WIIMOTE_IS_CONNECTED(wm)) if (!wm || WIIMOTE_IS_CONNECTED(wm)) {
return 0; return 0;
}
addr.l2_family = AF_BLUETOOTH; addr.l2_family = AF_BLUETOOTH;
bdaddr_t *bdaddr = &wm->bdaddr; bdaddr_t *bdaddr = &wm->bdaddr;
if (address) if (address)
/* use provided address */ /* use provided address */
str2ba(address, &addr.l2_bdaddr);
else
{ {
str2ba(address, &addr.l2_bdaddr);
} else {
/** @todo this line doesn't make sense /** @todo this line doesn't make sense
bacmp(bdaddr, BDADDR_ANY);*/ bacmp(bdaddr, BDADDR_ANY);*/
/* use address of device discovered */ /* use address of device discovered */
@@ -173,8 +176,9 @@ static int wiiuse_os_connect_single(struct wiimote_t* wm, char* address) {
* OUTPUT CHANNEL * OUTPUT CHANNEL
*/ */
wm->out_sock = socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP); wm->out_sock = socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
if (wm->out_sock == -1) if (wm->out_sock == -1) {
return 0; return 0;
}
addr.l2_psm = htobs(WM_OUTPUT_CHANNEL); addr.l2_psm = htobs(WM_OUTPUT_CHANNEL);
@@ -216,8 +220,9 @@ static int wiiuse_os_connect_single(struct wiimote_t* wm, char* address) {
} }
void wiiuse_os_disconnect(struct wiimote_t* wm) { void wiiuse_os_disconnect(struct wiimote_t* wm) {
if (!wm || WIIMOTE_IS_CONNECTED(wm)) if (!wm || WIIMOTE_IS_CONNECTED(wm)) {
return; return;
}
close(wm->out_sock); close(wm->out_sock);
close(wm->in_sock); close(wm->in_sock);
@@ -241,7 +246,9 @@ int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes) {
int highest_fd = -1; int highest_fd = -1;
evnt = 0; evnt = 0;
if (!wm) return 0; if (!wm) {
return 0;
}
/* block select() for 1/2000th of a second */ /* block select() for 1/2000th of a second */
tv.tv_sec = 0; tv.tv_sec = 0;
@@ -255,8 +262,9 @@ int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes) {
FD_SET(wm[i]->in_sock, &fds); FD_SET(wm[i]->in_sock, &fds);
/* find the highest fd of the connected wiimotes */ /* find the highest fd of the connected wiimotes */
if (wm[i]->in_sock > highest_fd) if (wm[i]->in_sock > highest_fd) {
highest_fd = wm[i]->in_sock; highest_fd = wm[i]->in_sock;
}
} }
wm[i]->event = WIIUSE_NONE; wm[i]->event = WIIUSE_NONE;
@@ -264,7 +272,9 @@ int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes) {
if (highest_fd == -1) if (highest_fd == -1)
/* nothing to poll */ /* nothing to poll */
{
return 0; return 0;
}
if (select(highest_fd + 1, &fds, NULL, NULL, &tv) == -1) { if (select(highest_fd + 1, &fds, NULL, NULL, &tv) == -1) {
WIIUSE_ERROR("Unable to select() the wiimote interrupt socket(s)."); WIIUSE_ERROR("Unable to select() the wiimote interrupt socket(s).");
@@ -275,8 +285,9 @@ int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes) {
/* check each socket for an event */ /* check each socket for an event */
for (i = 0; i < wiimotes; ++i) { for (i = 0; i < wiimotes; ++i) {
/* if this wiimote is not connected, skip it */ /* if this wiimote is not connected, skip it */
if (!WIIMOTE_IS_CONNECTED(wm[i])) if (!WIIMOTE_IS_CONNECTED(wm[i])) {
continue; continue;
}
if (FD_ISSET(wm[i]->in_sock, &fds)) { if (FD_ISSET(wm[i]->in_sock, &fds)) {
/* clear out the event buffer */ /* clear out the event buffer */
@@ -289,7 +300,7 @@ int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes) {
r = wiiuse_os_read(wm[i], read_buffer, sizeof(read_buffer)); r = wiiuse_os_read(wm[i], read_buffer, sizeof(read_buffer));
if (r > 0) { if (r > 0) {
/* propagate the event */ /* propagate the event */
propagate_event(wm[i], read_buffer[0], read_buffer+1); propagate_event(wm[i], read_buffer[0], read_buffer + 1);
evnt += (wm[i]->event != WIIUSE_NONE); evnt += (wm[i]->event != WIIUSE_NONE);
} }
} else { } else {
@@ -319,20 +330,20 @@ int wiiuse_os_read(struct wiimote_t* wm, byte* buf, int len) {
wiiuse_os_disconnect(wm); wiiuse_os_disconnect(wm);
wiiuse_disconnected(wm); wiiuse_disconnected(wm);
} }
} else if(rc == 0) { } else if (rc == 0) {
/* remote disconnect */ /* remote disconnect */
wiiuse_disconnected(wm); wiiuse_disconnected(wm);
} else { } else {
/* read successful */ /* read successful */
/* on *nix we ignore the first byte */ /* on *nix we ignore the first byte */
memmove(buf, buf+1, len-1); memmove(buf, buf + 1, len - 1);
/* log the received data */ /* log the received data */
#ifdef WITH_WIIUSE_DEBUG #ifdef WITH_WIIUSE_DEBUG
{ {
int i; int i;
printf("[DEBUG] (id %i) RECV: (%.2x) ", wm->unid, buf[0]); printf("[DEBUG] (id %i) RECV: (%.2x) ", wm->unid, buf[0]);
for(i = 1; i < rc; i++) { for (i = 1; i < rc; i++) {
printf("%.2x ", buf[i]); printf("%.2x ", buf[i]);
} }
printf("\n"); printf("\n");
@@ -349,11 +360,12 @@ int wiiuse_os_write(struct wiimote_t* wm, byte report_type, byte* buf, int len)
write_buffer[0] = WM_SET_REPORT | WM_BT_OUTPUT; write_buffer[0] = WM_SET_REPORT | WM_BT_OUTPUT;
write_buffer[1] = report_type; write_buffer[1] = report_type;
memcpy(write_buffer+2, buf, len); memcpy(write_buffer + 2, buf, len);
rc = write(wm->out_sock, write_buffer, len+2); rc = write(wm->out_sock, write_buffer, len + 2);
if(rc < 0) if (rc < 0) {
wiiuse_disconnected(wm); wiiuse_disconnected(wm);
}
return rc; return rc;
} }

83
src/os_win.c
View File

@@ -84,8 +84,9 @@ int wiiuse_os_find(struct wiimote_t** wm, int max_wiimotes, int timeout) {
} }
/* query the next hid device info */ /* query the next hid device info */
if (!SetupDiEnumDeviceInterfaces(device_info, NULL, &device_id, index, &device_data)) if (!SetupDiEnumDeviceInterfaces(device_info, NULL, &device_id, index, &device_data)) {
break; break;
}
/* get the size of the data block required */ /* get the size of the data block required */
i = SetupDiGetDeviceInterfaceDetail(device_info, &device_data, NULL, 0, &len, NULL); i = SetupDiGetDeviceInterfaceDetail(device_info, &device_data, NULL, 0, &len, NULL);
@@ -93,16 +94,18 @@ int wiiuse_os_find(struct wiimote_t** wm, int max_wiimotes, int timeout) {
detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
/* query the data for this device */ /* query the data for this device */
if (!SetupDiGetDeviceInterfaceDetail(device_info, &device_data, detail_data, len, NULL, NULL)) if (!SetupDiGetDeviceInterfaceDetail(device_info, &device_data, detail_data, len, NULL, NULL)) {
continue; continue;
}
/* open the device */ /* open the device */
dev = CreateFile(detail_data->DevicePath, dev = CreateFile(detail_data->DevicePath,
(GENERIC_READ | GENERIC_WRITE), (GENERIC_READ | GENERIC_WRITE),
(FILE_SHARE_READ | FILE_SHARE_WRITE), (FILE_SHARE_READ | FILE_SHARE_WRITE),
NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
if (dev == INVALID_HANDLE_VALUE) if (dev == INVALID_HANDLE_VALUE) {
continue; continue;
}
/* get device attributes */ /* get device attributes */
attr.Size = sizeof(attr); attr.Size = sizeof(attr);
@@ -131,16 +134,18 @@ int wiiuse_os_find(struct wiimote_t** wm, int max_wiimotes, int timeout) {
WIIUSE_INFO("Connected to wiimote [id %i].", wm[found]->unid); WIIUSE_INFO("Connected to wiimote [id %i].", wm[found]->unid);
++found; ++found;
if (found >= max_wiimotes) if (found >= max_wiimotes) {
break; break;
}
} else { } else {
/* not a wiimote */ /* not a wiimote */
CloseHandle(dev); CloseHandle(dev);
} }
} }
if (detail_data) if (detail_data) {
free(detail_data); free(detail_data);
}
SetupDiDestroyDeviceInfoList(device_info); SetupDiDestroyDeviceInfoList(device_info);
@@ -153,10 +158,12 @@ int wiiuse_os_connect(struct wiimote_t** wm, int wiimotes) {
int i = 0; int i = 0;
for (; i < wiimotes; ++i) { for (; i < wiimotes; ++i) {
if (!wm[i]) if (!wm[i]) {
continue; continue;
if (WIIMOTE_IS_SET(wm[i], WIIMOTE_STATE_CONNECTED)) }
if (WIIMOTE_IS_SET(wm[i], WIIMOTE_STATE_CONNECTED)) {
++connected; ++connected;
}
} }
return connected; return connected;
@@ -164,8 +171,9 @@ int wiiuse_os_connect(struct wiimote_t** wm, int wiimotes) {
void wiiuse_os_disconnect(struct wiimote_t* wm) { void wiiuse_os_disconnect(struct wiimote_t* wm) {
if (!wm || WIIMOTE_IS_CONNECTED(wm)) if (!wm || WIIMOTE_IS_CONNECTED(wm)) {
return; return;
}
CloseHandle(wm->dev_handle); CloseHandle(wm->dev_handle);
wm->dev_handle = 0; wm->dev_handle = 0;
@@ -184,7 +192,9 @@ int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes) {
byte read_buffer[MAX_PAYLOAD]; byte read_buffer[MAX_PAYLOAD];
int evnt = 0; int evnt = 0;
if (!wm) return 0; if (!wm) {
return 0;
}
for (i = 0; i < wiimotes; ++i) { for (i = 0; i < wiimotes; ++i) {
wm[i]->event = WIIUSE_NONE; wm[i]->event = WIIUSE_NONE;
@@ -194,7 +204,7 @@ int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes) {
/* read */ /* read */
if (wiiuse_os_read(wm[i], read_buffer, sizeof(read_buffer))) { if (wiiuse_os_read(wm[i], read_buffer, sizeof(read_buffer))) {
/* propagate the event */ /* propagate the event */
propagate_event(wm[i], read_buffer[0], read_buffer+1); propagate_event(wm[i], read_buffer[0], read_buffer + 1);
evnt += (wm[i]->event != WIIUSE_NONE); evnt += (wm[i]->event != WIIUSE_NONE);
} else { } else {
/* send out any waiting writes */ /* send out any waiting writes */
@@ -209,8 +219,9 @@ int wiiuse_os_poll(struct wiimote_t** wm, int wiimotes) {
int wiiuse_os_read(struct wiimote_t* wm, byte* buf, int len) { int wiiuse_os_read(struct wiimote_t* wm, byte* buf, int len) {
DWORD b, r; DWORD b, r;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return 0; return 0;
}
if (!ReadFile(wm->dev_handle, buf, len, &b, &wm->hid_overlap)) { if (!ReadFile(wm->dev_handle, buf, len, &b, &wm->hid_overlap)) {
/* partial read */ /* partial read */
@@ -226,8 +237,9 @@ int wiiuse_os_read(struct wiimote_t* wm, byte* buf, int len) {
if (r == WAIT_TIMEOUT) { if (r == WAIT_TIMEOUT) {
/* timeout - cancel and continue */ /* timeout - cancel and continue */
if (*buf) if (*buf) {
WIIUSE_WARNING("Packet ignored. This may indicate a problem (timeout is %i ms).", wm->timeout); WIIUSE_WARNING("Packet ignored. This may indicate a problem (timeout is %i ms).", wm->timeout);
}
CancelIo(wm->dev_handle); CancelIo(wm->dev_handle);
ResetEvent(wm->hid_overlap.hEvent); ResetEvent(wm->hid_overlap.hEvent);
@@ -237,15 +249,16 @@ int wiiuse_os_read(struct wiimote_t* wm, byte* buf, int len) {
return 0; return 0;
} }
if (!GetOverlappedResult(wm->dev_handle, &wm->hid_overlap, &b, 0)) if (!GetOverlappedResult(wm->dev_handle, &wm->hid_overlap, &b, 0)) {
return 0; return 0;
}
/* log the received data */ /* log the received data */
#ifdef WITH_WIIUSE_DEBUG #ifdef WITH_WIIUSE_DEBUG
{ {
DWORD i; DWORD i;
printf("[DEBUG] (id %i) RECV: (%.2x) ", wm->unid, buf[0]); printf("[DEBUG] (id %i) RECV: (%.2x) ", wm->unid, buf[0]);
for(i = 1; i < b; i++) { for (i = 1; i < b; i++) {
printf("%.2x ", buf[i]); printf("%.2x ", buf[i]);
} }
printf("\n"); printf("\n");
@@ -263,33 +276,33 @@ int wiiuse_os_write(struct wiimote_t* wm, byte report_type, byte* buf, int len)
int i; int i;
byte write_buffer[MAX_PAYLOAD]; byte write_buffer[MAX_PAYLOAD];
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return 0; return 0;
}
write_buffer[0] = report_type; write_buffer[0] = report_type;
memcpy(write_buffer+1, buf, len); memcpy(write_buffer + 1, buf, len);
switch (wm->stack) { switch (wm->stack) {
case WIIUSE_STACK_UNKNOWN: case WIIUSE_STACK_UNKNOWN: {
{ /* try to auto-detect the stack type */
/* try to auto-detect the stack type */ if (i = WriteFile(wm->dev_handle, write_buffer, 22, &bytes, &wm->hid_overlap)) {
if (i = WriteFile(wm->dev_handle, write_buffer, 22, &bytes, &wm->hid_overlap)) { /* bluesoleil will always return 1 here, even if it's not connected */
/* bluesoleil will always return 1 here, even if it's not connected */ wm->stack = WIIUSE_STACK_BLUESOLEIL;
wm->stack = WIIUSE_STACK_BLUESOLEIL; return i;
return i; }
}
if (i = HidD_SetOutputReport(wm->dev_handle, write_buffer, len+1)) { if (i = HidD_SetOutputReport(wm->dev_handle, write_buffer, len + 1)) {
wm->stack = WIIUSE_STACK_MS; wm->stack = WIIUSE_STACK_MS;
return i; return i;
} }
WIIUSE_ERROR("Unable to determine bluetooth stack type."); WIIUSE_ERROR("Unable to determine bluetooth stack type.");
return 0; return 0;
} }
case WIIUSE_STACK_MS: case WIIUSE_STACK_MS:
return HidD_SetOutputReport(wm->dev_handle, write_buffer, len+1); return HidD_SetOutputReport(wm->dev_handle, write_buffer, len + 1);
case WIIUSE_STACK_BLUESOLEIL: case WIIUSE_STACK_BLUESOLEIL:
return WriteFile(wm->dev_handle, write_buffer, 22, &bytes, &wm->hid_overlap); return WriteFile(wm->dev_handle, write_buffer, 22, &bytes, &wm->hid_overlap);

22
src/wiiboard.c
View File

@@ -53,14 +53,13 @@ int wii_board_handshake(struct wiimote_t* wm, struct wii_board_t* wb, byte* data
#ifdef WITH_WIIUSE_DEBUG #ifdef WITH_WIIUSE_DEBUG
int i; int i;
printf("DECRYPTED DATA WIIBOARD\n"); printf("DECRYPTED DATA WIIBOARD\n");
for (i = 0; i < len; ++i) for (i = 0; i < len; ++i) {
{ if (i % 16 == 0) {
if(i%16==0) if (i != 0) {
{
if(i!=0)
printf("\n"); printf("\n");
}
printf("%X: ",0x4a40000+32+i); printf("%X: ", 0x4a40000 + 32 + i);
} }
printf("%02X ", data[i]); printf("%02X ", data[i]);
} }
@@ -87,9 +86,9 @@ int wii_board_handshake(struct wiimote_t* wm, struct wii_board_t* wb, byte* data
wm->event = WIIUSE_WII_BOARD_CTRL_INSERTED; wm->event = WIIUSE_WII_BOARD_CTRL_INSERTED;
wm->exp.type = EXP_WII_BOARD; wm->exp.type = EXP_WII_BOARD;
#ifdef WIIUSE_WIN32 #ifdef WIIUSE_WIN32
wm->timeout = WIIMOTE_DEFAULT_TIMEOUT; wm->timeout = WIIMOTE_DEFAULT_TIMEOUT;
#endif #endif
return 1; return 1;
} }
@@ -109,9 +108,9 @@ static float do_interpolate(uint16_t raw, uint16_t cal[3]) {
if (raw < cal[0]) { if (raw < cal[0]) {
return 0.0f; return 0.0f;
} else if (raw < cal[1]) { } else if (raw < cal[1]) {
return ((float)(raw-cal[0]) * WIIBOARD_MIDDLE_CALIB)/(float)(cal[1] - cal[0]); return ((float)(raw - cal[0]) * WIIBOARD_MIDDLE_CALIB) / (float)(cal[1] - cal[0]);
} else if (raw < cal[2]) { } else if (raw < cal[2]) {
return ((float)(raw-cal[1]) * WIIBOARD_MIDDLE_CALIB)/(float)(cal[2] - cal[1]) + WIIBOARD_MIDDLE_CALIB; return ((float)(raw - cal[1]) * WIIBOARD_MIDDLE_CALIB) / (float)(cal[2] - cal[1]) + WIIBOARD_MIDDLE_CALIB;
} else { } else {
return WIIBOARD_MIDDLE_CALIB * 2.0f; return WIIBOARD_MIDDLE_CALIB * 2.0f;
} }
@@ -143,6 +142,5 @@ void wii_board_event(struct wii_board_t* wb, byte* msg) {
/** /**
@todo not implemented! @todo not implemented!
*/ */
void wiiuse_set_wii_board_calib(struct wiimote_t *wm) void wiiuse_set_wii_board_calib(struct wiimote_t *wm) {
{
} }

12
src/wiiboard.h
View File

@@ -40,14 +40,14 @@
extern "C" { extern "C" {
#endif #endif
/** @defgroup internal_wiiboard Internal: Wii Balance Board */ /** @defgroup internal_wiiboard Internal: Wii Balance Board */
/** @{ */ /** @{ */
int wii_board_handshake(struct wiimote_t* wm, struct wii_board_t* wb, byte* data, uint16_t len); int wii_board_handshake(struct wiimote_t* wm, struct wii_board_t* wb, byte* data, uint16_t len);
void wii_board_disconnected(struct wii_board_t* wb); void wii_board_disconnected(struct wii_board_t* wb);
void wii_board_event(struct wii_board_t* wb, byte* msg); void wii_board_event(struct wii_board_t* wb, byte* msg);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

222
src/wiiuse.c
View File

@@ -67,8 +67,7 @@ FILE* logtarget[4];
* *
* The default <code>FILE*</code> for all loglevels is <code>stderr</code> * The default <code>FILE*</code> for all loglevels is <code>stderr</code>
*/ */
void wiiuse_set_output(enum wiiuse_loglevel loglevel, FILE *logfile) void wiiuse_set_output(enum wiiuse_loglevel loglevel, FILE *logfile) {
{
logtarget[(int)loglevel] = logfile; logtarget[(int)loglevel] = logfile;
} }
@@ -78,8 +77,9 @@ void wiiuse_set_output(enum wiiuse_loglevel loglevel, FILE *logfile)
void wiiuse_cleanup(struct wiimote_t** wm, int wiimotes) { void wiiuse_cleanup(struct wiimote_t** wm, int wiimotes) {
int i = 0; int i = 0;
if (!wm) if (!wm) {
return; return;
}
WIIUSE_INFO("wiiuse clean up..."); WIIUSE_INFO("wiiuse clean up...");
@@ -120,9 +120,9 @@ struct wiimote_t** wiiuse_init(int wiimotes) {
* to call this function again it won't be intrusive. * to call this function again it won't be intrusive.
*/ */
if (!g_banner) { if (!g_banner) {
printf( "wiiuse v" WIIUSE_VERSION " loaded.\n" printf("wiiuse v" WIIUSE_VERSION " loaded.\n"
" Fork at http://github.com/rpavlik/wiiuse\n" " Fork at http://github.com/rpavlik/wiiuse\n"
" Original By: Michael Laforest <thepara[at]gmail{dot}com> http://wiiuse.net\n"); " Original By: Michael Laforest <thepara[at]gmail{dot}com> http://wiiuse.net\n");
g_banner = 1; g_banner = 1;
} }
@@ -131,8 +131,9 @@ struct wiimote_t** wiiuse_init(int wiimotes) {
logtarget[2] = stderr; logtarget[2] = stderr;
logtarget[3] = stderr; logtarget[3] = stderr;
if (!wiimotes) if (!wiimotes) {
return NULL; return NULL;
}
wm = malloc(sizeof(struct wiimote_t*) * wiimotes); wm = malloc(sizeof(struct wiimote_t*) * wiimotes);
@@ -140,7 +141,7 @@ struct wiimote_t** wiiuse_init(int wiimotes) {
wm[i] = malloc(sizeof(struct wiimote_t)); wm[i] = malloc(sizeof(struct wiimote_t));
memset(wm[i], 0, sizeof(struct wiimote_t)); memset(wm[i], 0, sizeof(struct wiimote_t));
wm[i]->unid = i+1; wm[i]->unid = i + 1;
wiiuse_init_platform_fields(wm[i]); wiiuse_init_platform_fields(wm[i]);
wm[i]->state = WIIMOTE_INIT_STATES; wm[i]->state = WIIMOTE_INIT_STATES;
@@ -170,7 +171,9 @@ struct wiimote_t** wiiuse_init(int wiimotes) {
* @param wm Pointer to a wiimote_t structure. * @param wm Pointer to a wiimote_t structure.
*/ */
void wiiuse_disconnected(struct wiimote_t* wm) { void wiiuse_disconnected(struct wiimote_t* wm) {
if (!wm) return; if (!wm) {
return;
}
WIIUSE_INFO("Wiimote disconnected [id %i].", wm->unid); WIIUSE_INFO("Wiimote disconnected [id %i].", wm->unid);
@@ -201,8 +204,9 @@ void wiiuse_disconnected(struct wiimote_t* wm) {
void wiiuse_rumble(struct wiimote_t* wm, int status) { void wiiuse_rumble(struct wiimote_t* wm, int status) {
byte buf; byte buf;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return; return;
}
/* make sure to keep the current lit leds */ /* make sure to keep the current lit leds */
buf = wm->leds; buf = wm->leds;
@@ -218,8 +222,9 @@ void wiiuse_rumble(struct wiimote_t* wm, int status) {
} }
/* preserve IR state */ /* preserve IR state */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR)) {
buf |= 0x04; buf |= 0x04;
}
wiiuse_send(wm, WM_CMD_RUMBLE, &buf, 1); wiiuse_send(wm, WM_CMD_RUMBLE, &buf, 1);
} }
@@ -231,7 +236,9 @@ void wiiuse_rumble(struct wiimote_t* wm, int status) {
* @param wm Pointer to a wiimote_t structure. * @param wm Pointer to a wiimote_t structure.
*/ */
void wiiuse_toggle_rumble(struct wiimote_t* wm) { void wiiuse_toggle_rumble(struct wiimote_t* wm) {
if (!wm) return; if (!wm) {
return;
}
wiiuse_rumble(wm, !WIIMOTE_IS_SET(wm, WIIMOTE_STATE_RUMBLE)); wiiuse_rumble(wm, !WIIMOTE_IS_SET(wm, WIIMOTE_STATE_RUMBLE));
} }
@@ -248,15 +255,17 @@ void wiiuse_toggle_rumble(struct wiimote_t* wm) {
void wiiuse_set_leds(struct wiimote_t* wm, int leds) { void wiiuse_set_leds(struct wiimote_t* wm, int leds) {
byte buf; byte buf;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return; return;
}
/* remove the lower 4 bits because they control rumble */ /* remove the lower 4 bits because they control rumble */
wm->leds = (leds & 0xF0); wm->leds = (leds & 0xF0);
/* make sure if the rumble is on that we keep it on */ /* make sure if the rumble is on that we keep it on */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_RUMBLE)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_RUMBLE)) {
wm->leds |= 0x01; wm->leds |= 0x01;
}
buf = wm->leds; buf = wm->leds;
@@ -275,10 +284,11 @@ void wiiuse_set_leds(struct wiimote_t* wm, int leds) {
* by default. * by default.
*/ */
void wiiuse_motion_sensing(struct wiimote_t* wm, int status) { void wiiuse_motion_sensing(struct wiimote_t* wm, int status) {
if (status) if (status) {
WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_ACC); WIIMOTE_ENABLE_STATE(wm, WIIMOTE_STATE_ACC);
else } else {
WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_ACC); WIIMOTE_DISABLE_STATE(wm, WIIMOTE_STATE_ACC);
}
wiiuse_set_report_type(wm); wiiuse_set_report_type(wm);
} }
@@ -300,34 +310,46 @@ int wiiuse_set_report_type(struct wiimote_t* wm) {
byte buf[2]; byte buf[2];
int motion, exp, ir; int motion, exp, ir;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return 0; return 0;
}
buf[0] = (WIIMOTE_IS_FLAG_SET(wm, WIIUSE_CONTINUOUS) ? 0x04 : 0x00); /* set to 0x04 for continuous reporting */ buf[0] = (WIIMOTE_IS_FLAG_SET(wm, WIIUSE_CONTINUOUS) ? 0x04 : 0x00); /* set to 0x04 for continuous reporting */
buf[1] = 0x00; buf[1] = 0x00;
/* if rumble is enabled, make sure we keep it */ /* if rumble is enabled, make sure we keep it */
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_RUMBLE)) if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_RUMBLE)) {
buf[0] |= 0x01; buf[0] |= 0x01;
}
motion = WIIMOTE_IS_SET(wm, WIIMOTE_STATE_ACC); motion = WIIMOTE_IS_SET(wm, WIIMOTE_STATE_ACC);
exp = WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP); exp = WIIMOTE_IS_SET(wm, WIIMOTE_STATE_EXP);
ir = WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR); ir = WIIMOTE_IS_SET(wm, WIIMOTE_STATE_IR);
if (motion && ir && exp) buf[1] = WM_RPT_BTN_ACC_IR_EXP; if (motion && ir && exp) {
else if (motion && exp) buf[1] = WM_RPT_BTN_ACC_EXP; buf[1] = WM_RPT_BTN_ACC_IR_EXP;
else if (motion && ir) buf[1] = WM_RPT_BTN_ACC_IR; } else if (motion && exp) {
else if (ir && exp) buf[1] = WM_RPT_BTN_IR_EXP; buf[1] = WM_RPT_BTN_ACC_EXP;
else if (ir) buf[1] = WM_RPT_BTN_ACC_IR; } else if (motion && ir) {
else if (exp) buf[1] = WM_RPT_BTN_EXP; buf[1] = WM_RPT_BTN_ACC_IR;
else if (motion) buf[1] = WM_RPT_BTN_ACC; } else if (ir && exp) {
else buf[1] = WM_RPT_BTN; buf[1] = WM_RPT_BTN_IR_EXP;
} else if (ir) {
buf[1] = WM_RPT_BTN_ACC_IR;
} else if (exp) {
buf[1] = WM_RPT_BTN_EXP;
} else if (motion) {
buf[1] = WM_RPT_BTN_ACC;
} else {
buf[1] = WM_RPT_BTN;
}
WIIUSE_DEBUG("Setting report type: 0x%x", buf[1]); WIIUSE_DEBUG("Setting report type: 0x%x", buf[1]);
exp = wiiuse_send(wm, WM_CMD_REPORT_TYPE, buf, 2); exp = wiiuse_send(wm, WM_CMD_REPORT_TYPE, buf, 2);
if (exp <= 0) if (exp <= 0) {
return exp; return exp;
}
return buf[1]; return buf[1];
} }
@@ -353,15 +375,18 @@ int wiiuse_set_report_type(struct wiimote_t* wm) {
int wiiuse_read_data_cb(struct wiimote_t* wm, wiiuse_read_cb read_cb, byte* buffer, unsigned int addr, uint16_t len) { int wiiuse_read_data_cb(struct wiimote_t* wm, wiiuse_read_cb read_cb, byte* buffer, unsigned int addr, uint16_t len) {
struct read_req_t* req; struct read_req_t* req;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return 0; return 0;
if (!buffer || !len) }
if (!buffer || !len) {
return 0; return 0;
}
/* make this request structure */ /* make this request structure */
req = (struct read_req_t*)malloc(sizeof(struct read_req_t)); req = (struct read_req_t*)malloc(sizeof(struct read_req_t));
if (req == NULL) if (req == NULL) {
return 0; return 0;
}
req->cb = read_cb; req->cb = read_cb;
req->buf = buffer; req->buf = buffer;
req->addr = addr; req->addr = addr;
@@ -381,7 +406,9 @@ int wiiuse_read_data_cb(struct wiimote_t* wm, wiiuse_read_cb read_cb, byte* buff
wiiuse_send_next_pending_read_request(wm); wiiuse_send_next_pending_read_request(wm);
} else { } else {
struct read_req_t* nptr = wm->read_req; struct read_req_t* nptr = wm->read_req;
for (; nptr->next; nptr = nptr->next); for (; nptr->next; nptr = nptr->next) {
;
}
nptr->next = req; nptr->next = req;
WIIUSE_DEBUG("Added pending data read request."); WIIUSE_DEBUG("Added pending data read request.");
@@ -425,16 +452,21 @@ void wiiuse_send_next_pending_read_request(struct wiimote_t* wm) {
byte buf[6]; byte buf[6];
struct read_req_t* req; struct read_req_t* req;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return; return;
if (!wm->read_req) return; }
if (!wm->read_req) {
return;
}
/* skip over dirty ones since they have already been read */ /* skip over dirty ones since they have already been read */
req = wm->read_req; req = wm->read_req;
while (req && req->dirty) while (req && req->dirty) {
req = req->next; req = req->next;
if (!req) }
if (!req) {
return; return;
}
/* the offset is in big endian */ /* the offset is in big endian */
to_big_endian_uint32_t(buf, req->addr); to_big_endian_uint32_t(buf, req->addr);
@@ -457,8 +489,9 @@ void wiiuse_send_next_pending_read_request(struct wiimote_t* wm) {
void wiiuse_status(struct wiimote_t* wm) { void wiiuse_status(struct wiimote_t* wm) {
byte buf = 0; byte buf = 0;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return; return;
}
WIIUSE_DEBUG("Requested wiimote status."); WIIUSE_DEBUG("Requested wiimote status.");
@@ -477,14 +510,17 @@ void wiiuse_status(struct wiimote_t* wm) {
*/ */
struct wiimote_t* wiiuse_get_by_id(struct wiimote_t** wm, int wiimotes, int unid) { struct wiimote_t* wiiuse_get_by_id(struct wiimote_t** wm, int wiimotes, int unid) {
int i = 0; int i = 0;
if (!wm) if (!wm) {
return NULL; return NULL;
}
for (; i < wiimotes; ++i) { for (; i < wiimotes; ++i) {
if (!wm[i]) if (!wm[i]) {
continue; continue;
if (wm[i]->unid == unid) }
if (wm[i]->unid == unid) {
return wm[i]; return wm[i];
}
} }
return NULL; return NULL;
@@ -503,22 +539,25 @@ int wiiuse_write_data(struct wiimote_t* wm, unsigned int addr, const byte* data,
byte buf[21] = {0}; /* the payload is always 23 */ byte buf[21] = {0}; /* the payload is always 23 */
byte * bufPtr = buf; byte * bufPtr = buf;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return 0; return 0;
if (!data || !len) }
if (!data || !len) {
return 0; return 0;
}
WIIUSE_DEBUG("Writing %i bytes to memory location 0x%x...", len, addr); WIIUSE_DEBUG("Writing %i bytes to memory location 0x%x...", len, addr);
#ifdef WITH_WIIUSE_DEBUG #ifdef WITH_WIIUSE_DEBUG
{ {
int i = 0; int i = 0;
printf("Write data is: "); printf("Write data is: ");
for (; i < len; ++i) for (; i < len; ++i) {
printf("%x ", data[i]); printf("%x ", data[i]);
}
printf("\n"); printf("\n");
} }
#endif #endif
/* the offset is in big endian */ /* the offset is in big endian */
buffer_big_endian_uint32_t(&bufPtr, (uint32_t)addr); buffer_big_endian_uint32_t(&bufPtr, (uint32_t)addr);
@@ -549,17 +588,20 @@ int wiiuse_write_data(struct wiimote_t* wm, unsigned int addr, const byte* data,
* to a pending list and be sent out when the previous * to a pending list and be sent out when the previous
* finishes. * finishes.
*/ */
int wiiuse_write_data_cb(struct wiimote_t *wm, unsigned int addr, byte *data, byte len, wiiuse_write_cb write_cb) int wiiuse_write_data_cb(struct wiimote_t *wm, unsigned int addr, byte *data, byte len, wiiuse_write_cb write_cb) {
{
struct data_req_t* req; struct data_req_t* req;
if(!wm || !WIIMOTE_IS_CONNECTED(wm)) return 0; if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
if( !data || !len ) return 0; return 0;
}
if (!data || !len) {
return 0;
}
req = (struct data_req_t*)malloc(sizeof(struct data_req_t)); req = (struct data_req_t*)malloc(sizeof(struct data_req_t));
req->cb = write_cb; req->cb = write_cb;
req->len = len; req->len = len;
memcpy(req->data,data,req->len); memcpy(req->data, data, req->len);
req->state = REQ_READY; req->state = REQ_READY;
req->addr = addr;/* BIG_ENDIAN_LONG(addr); */ req->addr = addr;/* BIG_ENDIAN_LONG(addr); */
req->next = NULL; req->next = NULL;
@@ -574,8 +616,10 @@ int wiiuse_write_data_cb(struct wiimote_t *wm, unsigned int addr, byte *data, by
wiiuse_send_next_pending_write_request(wm); wiiuse_send_next_pending_write_request(wm);
} else { } else {
struct data_req_t* nptr = wm->data_req; struct data_req_t* nptr = wm->data_req;
WIIUSE_DEBUG("chaud2fois"); WIIUSE_DEBUG("chaud2fois");
for (; nptr->next; nptr = nptr->next); for (; nptr->next; nptr = nptr->next) {
;
}
nptr->next = req; nptr->next = req;
WIIUSE_DEBUG("Added pending data write request."); WIIUSE_DEBUG("Added pending data write request.");
@@ -596,14 +640,19 @@ WIIUSE_DEBUG("chaud2fois");
void wiiuse_send_next_pending_write_request(struct wiimote_t* wm) { void wiiuse_send_next_pending_write_request(struct wiimote_t* wm) {
struct data_req_t* req; struct data_req_t* req;
if (!wm || !WIIMOTE_IS_CONNECTED(wm)) if (!wm || !WIIMOTE_IS_CONNECTED(wm)) {
return; return;
}
req = wm->data_req; req = wm->data_req;
if (!req) if (!req) {
return; return;
if (!req->data || !req->len) }
if (!req->data || !req->len) {
return; return;
if(req->state!=REQ_READY) return; }
if (req->state != REQ_READY) {
return;
}
wiiuse_write_data(wm, req->addr, req->data, req->len); wiiuse_write_data(wm, req->addr, req->data, req->len);
@@ -625,26 +674,27 @@ int wiiuse_send(struct wiimote_t* wm, byte report_type, byte* msg, int len) {
switch (report_type) { switch (report_type) {
case WM_CMD_LED: case WM_CMD_LED:
case WM_CMD_RUMBLE: case WM_CMD_RUMBLE:
case WM_CMD_CTRL_STATUS: case WM_CMD_CTRL_STATUS: {
{ /* Rumble flag for: 0x11, 0x13, 0x14, 0x15, 0x19 or 0x1a */
/* Rumble flag for: 0x11, 0x13, 0x14, 0x15, 0x19 or 0x1a */ if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_RUMBLE)) {
if (WIIMOTE_IS_SET(wm, WIIMOTE_STATE_RUMBLE)) msg[0] |= 0x01;
msg[0] |= 0x01; }
break; break;
} }
default: default:
break; break;
} }
#ifdef WITH_WIIUSE_DEBUG #ifdef WITH_WIIUSE_DEBUG
{ {
int x; int x;
printf("[DEBUG] (id %i) SEND: (%.2x) %.2x ", wm->unid, report_type, msg[0]); printf("[DEBUG] (id %i) SEND: (%.2x) %.2x ", wm->unid, report_type, msg[0]);
for (x = 1; x < len; ++x) for (x = 1; x < len; ++x) {
printf("%.2x ", msg[x]); printf("%.2x ", msg[x]);
}
printf("\n"); printf("\n");
} }
#endif #endif
return wiiuse_os_write(wm, report_type, msg, len); return wiiuse_os_write(wm, report_type, msg, len);
} }
@@ -663,7 +713,9 @@ int wiiuse_send(struct wiimote_t* wm, byte report_type, byte* msg, int len) {
* Flags are defined in wiiuse.h. * Flags are defined in wiiuse.h.
*/ */
int wiiuse_set_flags(struct wiimote_t* wm, int enable, int disable) { int wiiuse_set_flags(struct wiimote_t* wm, int enable, int disable) {
if (!wm) return 0; if (!wm) {
return 0;
}
/* remove mutually exclusive flags */ /* remove mutually exclusive flags */
enable &= ~disable; enable &= ~disable;
@@ -692,15 +744,18 @@ int wiiuse_set_flags(struct wiimote_t* wm, int enable, int disable) {
float wiiuse_set_smooth_alpha(struct wiimote_t* wm, float alpha) { float wiiuse_set_smooth_alpha(struct wiimote_t* wm, float alpha) {
float old; float old;
if (!wm) return 0.0f; if (!wm) {
return 0.0f;
}
old = wm->accel_calib.st_alpha; old = wm->accel_calib.st_alpha;
wm->accel_calib.st_alpha = alpha; wm->accel_calib.st_alpha = alpha;
/* if there is a nunchuk set that too */ /* if there is a nunchuk set that too */
if (wm->exp.type == EXP_NUNCHUK) if (wm->exp.type == EXP_NUNCHUK) {
wm->exp.nunchuk.accel_calib.st_alpha = alpha; wm->exp.nunchuk.accel_calib.st_alpha = alpha;
}
return old; return old;
} }
@@ -714,14 +769,17 @@ float wiiuse_set_smooth_alpha(struct wiimote_t* wm, float alpha) {
* @param type The type of bluetooth stack to use. * @param type The type of bluetooth stack to use.
*/ */
void wiiuse_set_bluetooth_stack(struct wiimote_t** wm, int wiimotes, enum win_bt_stack_t type) { void wiiuse_set_bluetooth_stack(struct wiimote_t** wm, int wiimotes, enum win_bt_stack_t type) {
#ifdef WIIUSE_WIN32 #ifdef WIIUSE_WIN32
int i; int i;
if (!wm) return; if (!wm) {
return;
}
for (i = 0; i < wiimotes; ++i) for (i = 0; i < wiimotes; ++i) {
wm[i]->stack = type; wm[i]->stack = type;
#endif }
#endif
} }
@@ -736,7 +794,9 @@ void wiiuse_set_bluetooth_stack(struct wiimote_t** wm, int wiimotes, enum win_bt
* the angle has to change by a full degree to generate an event. * the angle has to change by a full degree to generate an event.
*/ */
void wiiuse_set_orient_threshold(struct wiimote_t* wm, float threshold) { void wiiuse_set_orient_threshold(struct wiimote_t* wm, float threshold) {
if (!wm) return; if (!wm) {
return;
}
wm->orient_threshold = threshold; wm->orient_threshold = threshold;
} }
@@ -749,7 +809,9 @@ void wiiuse_set_orient_threshold(struct wiimote_t* wm, float threshold) {
* @param threshold The decimal place that should be considered a significant change. * @param threshold The decimal place that should be considered a significant change.
*/ */
void wiiuse_set_accel_threshold(struct wiimote_t* wm, int threshold) { void wiiuse_set_accel_threshold(struct wiimote_t* wm, int threshold) {
if (!wm) return; if (!wm) {
return;
}
wm->accel_threshold = threshold; wm->accel_threshold = threshold;
} }
@@ -761,7 +823,9 @@ void wiiuse_set_accel_threshold(struct wiimote_t* wm, int threshold) {
* @param wm Pointer to a wiimote_t structure. * @param wm Pointer to a wiimote_t structure.
*/ */
void wiiuse_resync(struct wiimote_t* wm) { void wiiuse_resync(struct wiimote_t* wm) {
if (!wm) return; if (!wm) {
return;
}
#ifndef WIIUSE_SYNC_HANDSHAKE #ifndef WIIUSE_SYNC_HANDSHAKE
wm->handshake_state = 0; wm->handshake_state = 0;
@@ -779,14 +843,16 @@ void wiiuse_resync(struct wiimote_t* wm) {
* @param exp_timeout The timeout in millisecondsd to wait for an expansion handshake. * @param exp_timeout The timeout in millisecondsd to wait for an expansion handshake.
*/ */
void wiiuse_set_timeout(struct wiimote_t** wm, int wiimotes, byte normal_timeout, byte exp_timeout) { void wiiuse_set_timeout(struct wiimote_t** wm, int wiimotes, byte normal_timeout, byte exp_timeout) {
#ifdef WIIUSE_WIN32 #ifdef WIIUSE_WIN32
int i; int i;
if (!wm) return; if (!wm) {
return;
}
for (i = 0; i < wiimotes; ++i) { for (i = 0; i < wiimotes; ++i) {
wm[i]->normal_timeout = normal_timeout; wm[i]->normal_timeout = normal_timeout;
wm[i]->exp_timeout = exp_timeout; wm[i]->exp_timeout = exp_timeout;
} }
#endif #endif
} }

156
src/wiiuse.h
View File

@@ -363,7 +363,7 @@ struct read_req_t {
* @brief Roll/Pitch/Yaw short angles. * @brief Roll/Pitch/Yaw short angles.
*/ */
typedef struct ang3s_t { typedef struct ang3s_t {
int16_t roll, pitch, yaw; int16_t roll, pitch, yaw;
} ang3s_t; } ang3s_t;
/** /**
@@ -371,7 +371,7 @@ typedef struct ang3s_t {
* @brief Roll/Pitch/Yaw float angles. * @brief Roll/Pitch/Yaw float angles.
*/ */
typedef struct ang3f_t { typedef struct ang3f_t {
float roll, pitch, yaw; float roll, pitch, yaw;
} ang3f_t; } ang3f_t;
/** /**
@@ -566,9 +566,8 @@ typedef struct guitar_hero_3_t {
/** /**
* @brief Motion Plus expansion device * @brief Motion Plus expansion device
*/ */
typedef struct motion_plus_t typedef struct motion_plus_t {
{ byte ext; /**< is there a device on the pass-through port? */
byte ext; /**< is there a device on the pass-through port? */
struct ang3s_t raw_gyro; /**< current raw gyroscope data */ struct ang3s_t raw_gyro; /**< current raw gyroscope data */
struct ang3s_t cal_gyro; /**< calibration raw gyroscope data */ struct ang3s_t cal_gyro; /**< calibration raw gyroscope data */
@@ -577,7 +576,7 @@ typedef struct motion_plus_t
byte acc_mode; /**< Fast/slow rotation mode for roll, pitch and yaw (0 if rotating fast, 1 if slow or still) */ byte acc_mode; /**< Fast/slow rotation mode for roll, pitch and yaw (0 if rotating fast, 1 if slow or still) */
int raw_gyro_threshold; /**< threshold for gyroscopes to generate an event */ int raw_gyro_threshold; /**< threshold for gyroscopes to generate an event */
struct nunchuk_t *nc; /**< pointers to nunchuk & classic in pass-through-mode */ struct nunchuk_t *nc; /**< pointers to nunchuk & classic in pass-through-mode */
struct classic_ctrl_t *classic; struct classic_ctrl_t *classic;
} motion_plus_t; } motion_plus_t;
@@ -718,34 +717,34 @@ typedef enum WIIUSE_EVENT_TYPE {
typedef struct wiimote_t { typedef struct wiimote_t {
WCONST int unid; /**< user specified id */ WCONST int unid; /**< user specified id */
#ifdef WIIUSE_BLUEZ #ifdef WIIUSE_BLUEZ
/** @name Linux-specific (BlueZ) members */ /** @name Linux-specific (BlueZ) members */
/** @{ */ /** @{ */
WCONST char bdaddr_str[18]; /**< readable bt address */ WCONST char bdaddr_str[18]; /**< readable bt address */
WCONST bdaddr_t bdaddr; /**< bt address */ WCONST bdaddr_t bdaddr; /**< bt address */
WCONST int out_sock; /**< output socket */ WCONST int out_sock; /**< output socket */
WCONST int in_sock; /**< input socket */ WCONST int in_sock; /**< input socket */
/** @} */ /** @} */
#endif #endif
#ifdef WIIUSE_WIN32 #ifdef WIIUSE_WIN32
/** @name Windows-specific members */ /** @name Windows-specific members */
/** @{ */ /** @{ */
WCONST HANDLE dev_handle; /**< HID handle */ WCONST HANDLE dev_handle; /**< HID handle */
WCONST OVERLAPPED hid_overlap; /**< overlap handle */ WCONST OVERLAPPED hid_overlap; /**< overlap handle */
WCONST enum win_bt_stack_t stack; /**< type of bluetooth stack to use */ WCONST enum win_bt_stack_t stack; /**< type of bluetooth stack to use */
WCONST int timeout; /**< read timeout */ WCONST int timeout; /**< read timeout */
WCONST byte normal_timeout; /**< normal timeout */ WCONST byte normal_timeout; /**< normal timeout */
WCONST byte exp_timeout; /**< timeout for expansion handshake */ WCONST byte exp_timeout; /**< timeout for expansion handshake */
/** @} */ /** @} */
#endif #endif
#ifdef WIIUSE_MAC #ifdef WIIUSE_MAC
/** @name Mac OS X-specific members */ /** @name Mac OS X-specific members */
/** @{ */ /** @{ */
WCONST void* objc_wm; /** WiiuseWiimote* as opaque pointer */ WCONST void* objc_wm; /** WiiuseWiimote* as opaque pointer */
/** @} */ /** @} */
#endif #endif
WCONST int state; /**< various state flags */ WCONST int state; /**< various state flags */
WCONST byte leds; /**< currently lit leds */ WCONST byte leds; /**< currently lit leds */
@@ -817,8 +816,7 @@ typedef void (*wiiuse_update_cb)(struct wiimote_callback_data_t* wm);
*/ */
typedef void (*wiiuse_write_cb)(struct wiimote_t* wm, unsigned char* data, unsigned short len); typedef void (*wiiuse_write_cb)(struct wiimote_t* wm, unsigned char* data, unsigned short len);
typedef enum data_req_s typedef enum data_req_s {
{
REQ_READY = 0, REQ_READY = 0,
REQ_SENT, REQ_SENT,
REQ_DONE REQ_DONE
@@ -877,69 +875,69 @@ typedef enum wiiuse_loglevel {
extern "C" { extern "C" {
#endif #endif
/* wiiuse.c */ /* wiiuse.c */
WIIUSE_EXPORT extern const char* wiiuse_version(); WIIUSE_EXPORT extern const char* wiiuse_version();
/** @brief Define indicating the presence of the feature allowing you to /** @brief Define indicating the presence of the feature allowing you to
* redirect output for one or more logging levels within the library. * redirect output for one or more logging levels within the library.
*/ */
#define WIIUSE_HAS_OUTPUT_REDIRECTION #define WIIUSE_HAS_OUTPUT_REDIRECTION
WIIUSE_EXPORT extern void wiiuse_set_output(enum wiiuse_loglevel loglevel, FILE *logtarget); WIIUSE_EXPORT extern void wiiuse_set_output(enum wiiuse_loglevel loglevel, FILE *logtarget);
WIIUSE_EXPORT extern struct wiimote_t** wiiuse_init(int wiimotes); WIIUSE_EXPORT extern struct wiimote_t** wiiuse_init(int wiimotes);
WIIUSE_EXPORT extern void wiiuse_disconnected(struct wiimote_t* wm); WIIUSE_EXPORT extern void wiiuse_disconnected(struct wiimote_t* wm);
WIIUSE_EXPORT extern void wiiuse_cleanup(struct wiimote_t** wm, int wiimotes); WIIUSE_EXPORT extern void wiiuse_cleanup(struct wiimote_t** wm, int wiimotes);
WIIUSE_EXPORT extern void wiiuse_rumble(struct wiimote_t* wm, int status); WIIUSE_EXPORT extern void wiiuse_rumble(struct wiimote_t* wm, int status);
WIIUSE_EXPORT extern void wiiuse_toggle_rumble(struct wiimote_t* wm); WIIUSE_EXPORT extern void wiiuse_toggle_rumble(struct wiimote_t* wm);
WIIUSE_EXPORT extern void wiiuse_set_leds(struct wiimote_t* wm, int leds); WIIUSE_EXPORT extern void wiiuse_set_leds(struct wiimote_t* wm, int leds);
WIIUSE_EXPORT extern void wiiuse_motion_sensing(struct wiimote_t* wm, int status); WIIUSE_EXPORT extern void wiiuse_motion_sensing(struct wiimote_t* wm, int status);
WIIUSE_EXPORT extern int wiiuse_read_data(struct wiimote_t* wm, byte* buffer, unsigned int offset, uint16_t len); WIIUSE_EXPORT extern int wiiuse_read_data(struct wiimote_t* wm, byte* buffer, unsigned int offset, uint16_t len);
WIIUSE_EXPORT extern int wiiuse_write_data(struct wiimote_t* wm, unsigned int addr, const byte* data, byte len); WIIUSE_EXPORT extern int wiiuse_write_data(struct wiimote_t* wm, unsigned int addr, const byte* data, byte len);
WIIUSE_EXPORT extern void wiiuse_status(struct wiimote_t* wm); WIIUSE_EXPORT extern void wiiuse_status(struct wiimote_t* wm);
WIIUSE_EXPORT extern struct wiimote_t* wiiuse_get_by_id(struct wiimote_t** wm, int wiimotes, int unid); WIIUSE_EXPORT extern struct wiimote_t* wiiuse_get_by_id(struct wiimote_t** wm, int wiimotes, int unid);
WIIUSE_EXPORT extern int wiiuse_set_flags(struct wiimote_t* wm, int enable, int disable); WIIUSE_EXPORT extern int wiiuse_set_flags(struct wiimote_t* wm, int enable, int disable);
WIIUSE_EXPORT extern float wiiuse_set_smooth_alpha(struct wiimote_t* wm, float alpha); WIIUSE_EXPORT extern float wiiuse_set_smooth_alpha(struct wiimote_t* wm, float alpha);
WIIUSE_EXPORT extern void wiiuse_set_bluetooth_stack(struct wiimote_t** wm, int wiimotes, enum win_bt_stack_t type); WIIUSE_EXPORT extern void wiiuse_set_bluetooth_stack(struct wiimote_t** wm, int wiimotes, enum win_bt_stack_t type);
WIIUSE_EXPORT extern void wiiuse_set_orient_threshold(struct wiimote_t* wm, float threshold); WIIUSE_EXPORT extern void wiiuse_set_orient_threshold(struct wiimote_t* wm, float threshold);
WIIUSE_EXPORT extern void wiiuse_resync(struct wiimote_t* wm); WIIUSE_EXPORT extern void wiiuse_resync(struct wiimote_t* wm);
WIIUSE_EXPORT extern void wiiuse_set_timeout(struct wiimote_t** wm, int wiimotes, byte normal_timeout, byte exp_timeout); WIIUSE_EXPORT extern void wiiuse_set_timeout(struct wiimote_t** wm, int wiimotes, byte normal_timeout, byte exp_timeout);
WIIUSE_EXPORT extern void wiiuse_set_accel_threshold(struct wiimote_t* wm, int threshold); WIIUSE_EXPORT extern void wiiuse_set_accel_threshold(struct wiimote_t* wm, int threshold);
/* io.c */ /* io.c */
WIIUSE_EXPORT extern int wiiuse_find(struct wiimote_t** wm, int max_wiimotes, int timeout); WIIUSE_EXPORT extern int wiiuse_find(struct wiimote_t** wm, int max_wiimotes, int timeout);
WIIUSE_EXPORT extern int wiiuse_connect(struct wiimote_t** wm, int wiimotes); WIIUSE_EXPORT extern int wiiuse_connect(struct wiimote_t** wm, int wiimotes);
WIIUSE_EXPORT extern void wiiuse_disconnect(struct wiimote_t* wm); WIIUSE_EXPORT extern void wiiuse_disconnect(struct wiimote_t* wm);
/* events.c */ /* events.c */
WIIUSE_EXPORT extern int wiiuse_poll(struct wiimote_t** wm, int wiimotes); WIIUSE_EXPORT extern int wiiuse_poll(struct wiimote_t** wm, int wiimotes);
/** /**
* @brief Poll Wiimotes, and call the provided callback with information * @brief Poll Wiimotes, and call the provided callback with information
* on each Wiimote that had an event. * on each Wiimote that had an event.
* *
* Alternative to calling wiiuse_poll yourself, and provides the same * Alternative to calling wiiuse_poll yourself, and provides the same
* information struct on all platforms. * information struct on all platforms.
* *
* @return Number of wiimotes that had an event. * @return Number of wiimotes that had an event.
*/ */
WIIUSE_EXPORT extern int wiiuse_update(struct wiimote_t** wm, int wiimotes, wiiuse_update_cb callback); WIIUSE_EXPORT extern int wiiuse_update(struct wiimote_t** wm, int wiimotes, wiiuse_update_cb callback);
/* ir.c */ /* ir.c */
WIIUSE_EXPORT extern void wiiuse_set_ir(struct wiimote_t* wm, int status); WIIUSE_EXPORT extern void wiiuse_set_ir(struct wiimote_t* wm, int status);
WIIUSE_EXPORT extern void wiiuse_set_ir_vres(struct wiimote_t* wm, unsigned int x, unsigned int y); WIIUSE_EXPORT extern void wiiuse_set_ir_vres(struct wiimote_t* wm, unsigned int x, unsigned int y);
WIIUSE_EXPORT extern void wiiuse_set_ir_position(struct wiimote_t* wm, enum ir_position_t pos); WIIUSE_EXPORT extern void wiiuse_set_ir_position(struct wiimote_t* wm, enum ir_position_t pos);
WIIUSE_EXPORT extern void wiiuse_set_aspect_ratio(struct wiimote_t* wm, enum aspect_t aspect); WIIUSE_EXPORT extern void wiiuse_set_aspect_ratio(struct wiimote_t* wm, enum aspect_t aspect);
WIIUSE_EXPORT extern void wiiuse_set_ir_sensitivity(struct wiimote_t* wm, int level); WIIUSE_EXPORT extern void wiiuse_set_ir_sensitivity(struct wiimote_t* wm, int level);
/* nunchuk.c */ /* nunchuk.c */
WIIUSE_EXPORT extern void wiiuse_set_nunchuk_orient_threshold(struct wiimote_t* wm, float threshold); WIIUSE_EXPORT extern void wiiuse_set_nunchuk_orient_threshold(struct wiimote_t* wm, float threshold);
WIIUSE_EXPORT extern void wiiuse_set_nunchuk_accel_threshold(struct wiimote_t* wm, int threshold); WIIUSE_EXPORT extern void wiiuse_set_nunchuk_accel_threshold(struct wiimote_t* wm, int threshold);
/* wiiboard.c */ /* wiiboard.c */
/* this function not currently implemented... */ /* this function not currently implemented... */
WIIUSE_EXPORT extern void wiiuse_set_wii_board_calib(struct wiimote_t *wm); WIIUSE_EXPORT extern void wiiuse_set_wii_board_calib(struct wiimote_t *wm);
WIIUSE_EXPORT extern void wiiuse_set_motion_plus(struct wiimote_t *wm, int status); WIIUSE_EXPORT extern void wiiuse_set_motion_plus(struct wiimote_t *wm, int status);
#ifdef __cplusplus #ifdef __cplusplus
} }

194
src/wiiuse_internal.h
View File

@@ -143,12 +143,12 @@
* not store them in such a way, rather it uses * not store them in such a way, rather it uses
* the concept of major service, major class, * the concept of major service, major class,
* and minor class, that are respectivelly * and minor class, that are respectivelly
* 11bit, 5bit, and 6bit long. Hence, the * 11bit, 5bit, and 6bit long. Hence, the
* numbers are different. * numbers are different.
* The Wiimote CoD Bluetooth division is the following: * The Wiimote CoD Bluetooth division is the following:
* 00000000001 00101 000001 00 (major service - major class - minor class - format type) * 00000000001 00101 000001 00 (major service - major class - minor class - format type)
* This can also be seen in the WiiC Linux way: * This can also be seen in the WiiC Linux way:
* 00000000 00100101 00000100 * 00000000 00100101 00000100
*/ */
#ifdef WIIUSE_MAC #ifdef WIIUSE_MAC
#define WM_DEV_MINOR_CLASS 0x01 #define WM_DEV_MINOR_CLASS 0x01
@@ -280,121 +280,121 @@
extern "C" { extern "C" {
#endif #endif
/* not part of the api */ /* not part of the api */
/** @brief Cross-platform call to sleep for at least the specified number /** @brief Cross-platform call to sleep for at least the specified number
* of milliseconds. * of milliseconds.
* *
* Use instead of Sleep(), usleep(), or similar functions. * Use instead of Sleep(), usleep(), or similar functions.
* Defined in util.c * Defined in util.c
*/ */
void wiiuse_millisleep(int durationMilliseconds); void wiiuse_millisleep(int durationMilliseconds);
int wiiuse_set_report_type(struct wiimote_t* wm); int wiiuse_set_report_type(struct wiimote_t* wm);
void wiiuse_send_next_pending_read_request(struct wiimote_t* wm); void wiiuse_send_next_pending_read_request(struct wiimote_t* wm);
void wiiuse_send_next_pending_write_request(struct wiimote_t* wm); void wiiuse_send_next_pending_write_request(struct wiimote_t* wm);
int wiiuse_send(struct wiimote_t* wm, byte report_type, byte* msg, int len); int wiiuse_send(struct wiimote_t* wm, byte report_type, byte* msg, int len);
int wiiuse_read_data_cb(struct wiimote_t* wm, wiiuse_read_cb read_cb, byte* buffer, unsigned int offset, uint16_t len); int wiiuse_read_data_cb(struct wiimote_t* wm, wiiuse_read_cb read_cb, byte* buffer, unsigned int offset, uint16_t len);
int wiiuse_write_data_cb(struct wiimote_t *wm, unsigned int addr, byte* data, byte len, wiiuse_write_cb write_cb); int wiiuse_write_data_cb(struct wiimote_t *wm, unsigned int addr, byte* data, byte len, wiiuse_write_cb write_cb);
#ifdef WIIUSE_DOXYGEN_PARSING #ifdef WIIUSE_DOXYGEN_PARSING
/** @addtogroup betosystem Big-endian buffer to system-byte-order value /** @addtogroup betosystem Big-endian buffer to system-byte-order value
@{ */ @{ */
/** @brief Given a buffer buf, copy and return a value of type uint8_t. /** @brief Given a buffer buf, copy and return a value of type uint8_t.
*/ */
uint8_t from_big_endian_uint8_t(byte * buf); uint8_t from_big_endian_uint8_t(byte * buf);
/** @brief Given a buffer buf, copy out a uint16_t, convert it from big-endian /** @brief Given a buffer buf, copy out a uint16_t, convert it from big-endian
to system byte order, and return it. to system byte order, and return it.
@note Requires that at least 2 bytes be available in buf, but does not @note Requires that at least 2 bytes be available in buf, but does not
check this - it is your responsibility. check this - it is your responsibility.
*/ */
uint16_t from_big_endian_uint16_t(byte * buf); uint16_t from_big_endian_uint16_t(byte * buf);
/** @brief Given a buffer buf, copy out a uint32_t, convert it from big-endian /** @brief Given a buffer buf, copy out a uint32_t, convert it from big-endian
to system byte order, and return it. to system byte order, and return it.
@note Requires that at least 4 bytes be available in buf, but does not @note Requires that at least 4 bytes be available in buf, but does not
check this - it is your responsibility. check this - it is your responsibility.
*/ */
uint32_t from_big_endian_uint32_t(byte * buf); uint32_t from_big_endian_uint32_t(byte * buf);
/** @} */ /** @} */
/** @addtogroup systemtobe System-byte-order value to big-endian buffer /** @addtogroup systemtobe System-byte-order value to big-endian buffer
@{ @{
*/ */
/** @brief Copies the value val into the buffer buf. /** @brief Copies the value val into the buffer buf.
@note Requires that at least 1 byte is available in buf, but does not @note Requires that at least 1 byte is available in buf, but does not
check this - it is your responsibility. check this - it is your responsibility.
*/ */
void to_big_endian_uint8_t(byte * buf, uint8_t val); void to_big_endian_uint8_t(byte * buf, uint8_t val);
/** @brief Converts the value val from system byte order to big endian, /** @brief Converts the value val from system byte order to big endian,
and copies it into the given buffer starting at buf. and copies it into the given buffer starting at buf.
@note Requires that at least 2 bytes be available in buf, but does not @note Requires that at least 2 bytes be available in buf, but does not
check this - it is your responsibility. check this - it is your responsibility.
*/ */
void to_big_endian_uint16_t(byte * buf, uint16_t val); void to_big_endian_uint16_t(byte * buf, uint16_t val);
/** @brief Converts the value val from system byte order to big endian, /** @brief Converts the value val from system byte order to big endian,
and copies it into the given buffer starting at buf. and copies it into the given buffer starting at buf.
@note Requires that at least 4 bytes be available in buf, but does not @note Requires that at least 4 bytes be available in buf, but does not
check this - it is your responsibility. check this - it is your responsibility.
*/ */
void to_big_endian_uint32_t(byte * buf, uint32_t val); void to_big_endian_uint32_t(byte * buf, uint32_t val);
/** @} /** @}
*/ */
/** @addtogroup bufferfunc Buffering functions /** @addtogroup bufferfunc Buffering functions
@brief These wrap around from/to_big_endian_TYPE, but take a byte** so that @brief These wrap around from/to_big_endian_TYPE, but take a byte** so that
they can advance the input/output pointer appropriately. they can advance the input/output pointer appropriately.
@{ @{
*/ */
/** @brief Converts the value val from system byte order to big endian, /** @brief Converts the value val from system byte order to big endian,
copies it into the given buffer starting at *buf, and advances buf by copies it into the given buffer starting at *buf, and advances buf by
sizeof(uint16_t). sizeof(uint16_t).
*/ */
void buffer_big_endian_uint16_t(byte ** buf, uint16_t val); void buffer_big_endian_uint16_t(byte ** buf, uint16_t val);
/** @brief Given the address of a buffer pointer buf, copy out a uint16_t /** @brief Given the address of a buffer pointer buf, copy out a uint16_t
from *buf, convert it from big-endian to system byte order, advance from *buf, convert it from big-endian to system byte order, advance
buf by sizeof(uint16_t), and return the value retrieved. buf by sizeof(uint16_t), and return the value retrieved.
*/ */
uint16_t unbuffer_big_endian_uint16_t(byte ** buf); uint16_t unbuffer_big_endian_uint16_t(byte ** buf);
/** @sa buffer_big_endian_uint16_t() /** @sa buffer_big_endian_uint16_t()
*/ */
void buffer_big_endian_uint8_t(byte ** buf, uint8_t val); void buffer_big_endian_uint8_t(byte ** buf, uint8_t val);
/** @sa unbuffer_big_endian_uint8_t /** @sa unbuffer_big_endian_uint8_t
*/ */
uint8_t unbuffer_big_endian_uint8_t(byte ** buf); uint8_t unbuffer_big_endian_uint8_t(byte ** buf);
/** @sa buffer_big_endian_uint16_t /** @sa buffer_big_endian_uint16_t
*/ */
void buffer_big_endian_uint32_t(byte ** buf, uint32_t val); void buffer_big_endian_uint32_t(byte ** buf, uint32_t val);
/** @sa unbuffer_big_endian_uint32_t /** @sa unbuffer_big_endian_uint32_t
*/ */
uint8_t unbuffer_big_endian_uint32_t(byte ** buf) uint8_t unbuffer_big_endian_uint32_t(byte ** buf)
/** @} */ /** @} */
#else /* this else is true when not in doxygen */ #else /* this else is true when not in doxygen */
INLINE_UTIL void to_big_endian_uint8_t(byte * buf, uint8_t val) { INLINE_UTIL void to_big_endian_uint8_t(byte * buf, uint8_t val) {
memcpy(buf, &val, 1); memcpy(buf, &val, 1);
} }
INLINE_UTIL uint8_t from_big_endian_uint8_t(byte * buf) { INLINE_UTIL uint8_t from_big_endian_uint8_t(byte * buf) {
uint8_t beVal; uint8_t beVal;
memcpy(&beVal, buf, 1); memcpy(&beVal, buf, 1);
return beVal; return beVal;
} }
#define WIIUSE_DECLARE_ENDIAN_CONVERSION_OPS(_TYPE, _TOBE, _FROMBE) \ #define WIIUSE_DECLARE_ENDIAN_CONVERSION_OPS(_TYPE, _TOBE, _FROMBE) \
INLINE_UTIL void to_big_endian_##_TYPE(byte * buf, _TYPE val) { \ INLINE_UTIL void to_big_endian_##_TYPE(byte * buf, _TYPE val) { \
@@ -407,8 +407,8 @@ INLINE_UTIL _TYPE from_big_endian_##_TYPE(byte * buf) { \
return _FROMBE(beVal); \ return _FROMBE(beVal); \
} }
WIIUSE_DECLARE_ENDIAN_CONVERSION_OPS(uint16_t, htons, ntohs) WIIUSE_DECLARE_ENDIAN_CONVERSION_OPS(uint16_t, htons, ntohs)
WIIUSE_DECLARE_ENDIAN_CONVERSION_OPS(uint32_t, htonl, ntohl) WIIUSE_DECLARE_ENDIAN_CONVERSION_OPS(uint32_t, htonl, ntohl)
#undef WIIUSE_DECLARE_ENDIAN_CONVERSION_OPS #undef WIIUSE_DECLARE_ENDIAN_CONVERSION_OPS
@@ -423,9 +423,9 @@ INLINE_UTIL _TYPE unbuffer_big_endian_##_TYPE (byte ** buf) { \
return from_big_endian_##_TYPE(current); \ return from_big_endian_##_TYPE(current); \
} }
WIIUSE_DECLARE_BUFFERING_OPS(uint8_t) WIIUSE_DECLARE_BUFFERING_OPS(uint8_t)
WIIUSE_DECLARE_BUFFERING_OPS(uint16_t) WIIUSE_DECLARE_BUFFERING_OPS(uint16_t)
WIIUSE_DECLARE_BUFFERING_OPS(uint32_t) WIIUSE_DECLARE_BUFFERING_OPS(uint32_t)
#undef WIIUSE_DECLARE_BUFFERING_OPS #undef WIIUSE_DECLARE_BUFFERING_OPS