ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed emulated Nunchuck in Mario Galaxy and Wii Sports 

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1222 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
John Peterson 2008-11-20 08:46:16 +00:00
parent aabee66444
commit 5fb23f879e
14 changed files with 328 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.cpp
View File

@ -944,7 +944,7 @@ namespace Core
{ {
LOGV(WII_IPC_WIIMOTE, 3, "========================================================="); LOGV(WII_IPC_WIIMOTE, 3, "=========================================================");
const u8* pData = (const u8*)_pData; const u8* pData = (const u8*)_pData;
LOGV(WII_IPC_WIIMOTE, 3, "Callback_WiimoteInput: 0x%x", _channelID); LOGV(WII_IPC_WIIMOTE, 3, "Callback_WiimoteInput:");
std::string Temp; std::string Temp;
for (u32 j=0; j<_Size; j++) for (u32 j=0; j<_Size; j++)
{ {
@ -953,6 +953,7 @@ namespace Core
Temp.append(Buffer); Temp.append(Buffer);
} }
LOGV(WII_IPC_WIIMOTE, 3, " Data: %s", Temp.c_str()); LOGV(WII_IPC_WIIMOTE, 3, " Data: %s", Temp.c_str());
//LOGV(WII_IPC_WIIMOTE, 3, " Channel: %s", _channelID);
s_Usb->m_WiiMotes[0].SendL2capData(_channelID, _pData, _Size); s_Usb->m_WiiMotes[0].SendL2capData(_channelID, _pData, _Size);
LOGV(WII_IPC_WIIMOTE, 3, "========================================================="); LOGV(WII_IPC_WIIMOTE, 3, "=========================================================");

2
Source/Core/DolphinWX/Src/BootManager.cpp
View File

@ -142,7 +142,7 @@ bool BootCore(const std::string& _rFilename)
} }
else else
{ {
PanicAlert("Could not write to SYSCONF"); PanicAlert("Could not read %sSYSCONF", FULL_CONFIG_DIR);
} }
// ---------------- // ----------------
} }

2
Source/Core/DolphinWX/Src/ConfigMain.cpp
View File

@ -72,7 +72,7 @@ CConfigMain::CConfigMain(wxWindow* parent, wxWindowID id, const wxString& title,
} }
else else
{ {
PanicAlert("Could not read Wii SYSCONF"); PanicAlert("Could not read " FULL_CONFIG_DIR "SYSCONF");
} }
CreateGUIControls(); CreateGUIControls();

2
Source/Plugins/Plugin_DSP_HLE/Src/Logging/Console.cpp
View File

@ -128,7 +128,7 @@ int aprintf(int a, char *fmt, ...)
// Printf to screen function // Printf to screen function
int wprintf(char *fmt, ...) int wprintf(char *fmt, ...)
{ {
#if defined(DEBUG_HLE) && defined(_WIN32) #if defined(DEBUG_HLE) && defined(_WIN32) && (defined(_DEBUG) || defined(DEBUGFAST))
char s[1024*20]; // Warning, mind this value char s[1024*20]; // Warning, mind this value
va_list argptr; va_list argptr;
int cnt; int cnt;

8
Source/Plugins/Plugin_Wiimote_Test/Plugin_Wiimote_Test.vcproj
View File

@ -576,6 +576,10 @@
RelativePath=".\Src\FillReport.cpp" RelativePath=".\Src\FillReport.cpp"
> >
</File> </File>
<File
RelativePath=".\Src\wiimote_hid.h"
>
</File>
</Filter> </Filter>
<Filter <Filter
Name="Real Wiimote" Name="Real Wiimote"
@ -613,10 +617,6 @@
RelativePath=".\Src\main.cpp" RelativePath=".\Src\main.cpp"
> >
</File> </File>
<File
RelativePath=".\Src\wiimote_hid.h"
>
</File>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>

5
Source/Plugins/Plugin_Wiimote_Test/Src/ConfigDlg.cpp
View File

@ -131,9 +131,10 @@ void ConfigDialog::GeneralSettingsChanged(wxCommandEvent& event)
g_Config.bExtensionConnected = m_ExtensionConnected->IsChecked(); g_Config.bExtensionConnected = m_ExtensionConnected->IsChecked();
// generate connect/disconnect status event // generate connect/disconnect status event
u8 DataFrame[8]; // make a blank report for it
wm_request_status *rs = (wm_request_status*)DataFrame;
if(WiiMoteEmu::g_ReportingChannel > 0) if(WiiMoteEmu::g_ReportingChannel > 0)
WiiMoteEmu::WmRequestStatus_(WiiMoteEmu::g_ReportingChannel, WiiMoteEmu::WmRequestStatus(WiiMoteEmu::g_ReportingChannel, rs);
g_Config.bExtensionConnected ? 1 : 0);
break; break;
} }
} }

45
Source/Plugins/Plugin_Wiimote_Test/Src/DataReports.cpp
View File

@ -16,6 +16,24 @@
// http://code.google.com/p/dolphin-emu/ // http://code.google.com/p/dolphin-emu/
// ===================================================
/* Data reports guide. The different structures location in the Input reports. The ? in
the IR coordinates is the High coordinates that are four in one byte. */
// ----------------
/* 0x33
[c.left etc] [c.a etc] acc.x y z ir0.x y ? ir1.x y ? ir2.x y ? ir3.x y ?
0x37
[c.left etc] [c.a etc] acc.x y z ir0.x1 y1 ? x2 y2 ir1.x1 y1 ? x2 y2 ext.jx jy ax ay az bt*/
// ================
#include "pluginspecs_wiimote.h" #include "pluginspecs_wiimote.h"
#include <vector> #include <vector>
@ -50,7 +68,6 @@ void WmDataReporting(u16 _channelID, wm_data_reporting* dr)
LOG(WII_IPC_WIIMOTE, " All The Time: %x (not only on data change)", dr->all_the_time); LOG(WII_IPC_WIIMOTE, " All The Time: %x (not only on data change)", dr->all_the_time);
LOG(WII_IPC_WIIMOTE, " Rumble: %x", dr->rumble); LOG(WII_IPC_WIIMOTE, " Rumble: %x", dr->rumble);
LOG(WII_IPC_WIIMOTE, " Mode: 0x%02x", dr->mode); LOG(WII_IPC_WIIMOTE, " Mode: 0x%02x", dr->mode);
//PanicAlert("Data reporting mode: 0x%02x", dr->mode);
wprintf("\nData reporting mode: 0x%02x", dr->mode); wprintf("\nData reporting mode: 0x%02x", dr->mode);
wprintf("\nData reporting channel: 0x%04x\n", _channelID); wprintf("\nData reporting channel: 0x%04x\n", _channelID);
@ -112,6 +129,18 @@ void SendReportCoreAccel(u16 _channelID)
LOGV(WII_IPC_WIIMOTE, 2, " SendReportCoreAccel()"); LOGV(WII_IPC_WIIMOTE, 2, " SendReportCoreAccel()");
// Debugging
/*if(GetAsyncKeyState('V'))
{
wprintf("DataFrame: ");
for (int i = 0; i < Offset; i++)
{
wprintf("%02x ", DataFrame[i]);
if((i + 1) % 30 == 0) wprintf("\n");
}
wprintf("\n");
}*/
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
} }
@ -129,6 +158,8 @@ void SendReportCoreAccelIr12(u16 _channelID) {
FillReportInfo(pReport->c); FillReportInfo(pReport->c);
FillReportAcc(pReport->a); FillReportAcc(pReport->a);
// We settle with emulating two objects, not all four
FillReportIR(pReport->ir[0], pReport->ir[1]); FillReportIR(pReport->ir[0], pReport->ir[1]);
LOGV(WII_IPC_WIIMOTE, 2, " SendReportCoreAccelIr12()"); LOGV(WII_IPC_WIIMOTE, 2, " SendReportCoreAccelIr12()");
@ -136,7 +167,7 @@ void SendReportCoreAccelIr12(u16 _channelID) {
// Debugging // Debugging
#ifdef _WIN32 #ifdef _WIN32
if(GetAsyncKeyState('V')) /*if(GetAsyncKeyState('V'))
{ {
wprintf("DataFrame: "); wprintf("DataFrame: ");
for (int i = 0; i < Offset; i++) for (int i = 0; i < Offset; i++)
@ -145,7 +176,7 @@ void SendReportCoreAccelIr12(u16 _channelID) {
if((i + 1) % 30 == 0) wprintf("\n"); if((i + 1) % 30 == 0) wprintf("\n");
} }
wprintf("\n"); wprintf("\n");
} }*/
#endif #endif
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
} }
@ -174,7 +205,7 @@ void SendReportCoreAccelExt16(u16 _channelID)
// Debugging // Debugging
#ifdef _WIN32 #ifdef _WIN32
if(GetAsyncKeyState('V')) /*if(GetAsyncKeyState('V'))
{ {
wprintf("DataFrame: "); wprintf("DataFrame: ");
for (int i = 0; i < Offset; i++) for (int i = 0; i < Offset; i++)
@ -183,7 +214,7 @@ void SendReportCoreAccelExt16(u16 _channelID)
if((i + 1) % 30 == 0) wprintf("\n"); if((i + 1) % 30 == 0) wprintf("\n");
} }
wprintf("\n"); wprintf("\n");
} }*/
#endif #endif
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
} }
@ -210,7 +241,7 @@ void SendReportCoreAccelIr10Ext(u16 _channelID)
// Debugging // Debugging
#ifdef _WIN32 #ifdef _WIN32
if(GetAsyncKeyState('V')) /*if(GetAsyncKeyState('V'))
{ {
wprintf("DataFrame: "); wprintf("DataFrame: ");
for (int i = 0; i < Offset; i++) for (int i = 0; i < Offset; i++)
@ -219,7 +250,7 @@ void SendReportCoreAccelIr10Ext(u16 _channelID)
if((i + 1) % 30 == 0) wprintf("\n"); if((i + 1) % 30 == 0) wprintf("\n");
} }
wprintf("\n"); wprintf("\n");
} }*/
#endif #endif
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
} }

3
Source/Plugins/Plugin_Wiimote_Test/Src/EmuDefinitions.cpp
View File

@ -29,8 +29,6 @@
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd #include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
extern SWiimoteInitialize g_WiimoteInitialize; extern SWiimoteInitialize g_WiimoteInitialize;
//extern void __Log(int log, const char *format, ...);
//extern void __Log(int log, int v, const char *format, ...);
namespace WiiMoteEmu namespace WiiMoteEmu
{ {
@ -46,7 +44,6 @@ u8 g_Eeprom[WIIMOTE_EEPROM_SIZE];
u8 g_RegSpeaker[WIIMOTE_REG_SPEAKER_SIZE]; u8 g_RegSpeaker[WIIMOTE_REG_SPEAKER_SIZE];
u8 g_RegExt[WIIMOTE_REG_EXT_SIZE]; u8 g_RegExt[WIIMOTE_REG_EXT_SIZE];
u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE]; u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE];
u8 g_RegExtBlnk[WIIMOTE_REG_EXT_SIZE];
u8 g_RegIr[WIIMOTE_REG_IR_SIZE]; u8 g_RegIr[WIIMOTE_REG_IR_SIZE];
u8 g_ReportingMode; // the reporting mode and channel id u8 g_ReportingMode; // the reporting mode and channel id

268
Source/Plugins/Plugin_Wiimote_Test/Src/EmuMain.cpp
View File

@ -24,6 +24,7 @@
#include "wiimote_hid.h" #include "wiimote_hid.h"
#include "EmuSubroutines.h" #include "EmuSubroutines.h"
#include "EmuDefinitions.h" #include "EmuDefinitions.h"
#include "EmuMain.h"
#include "Encryption.h" // for extension encryption #include "Encryption.h" // for extension encryption
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd #include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Config.h" // for g_Config #include "Config.h" // for g_Config
@ -41,20 +42,21 @@ namespace WiiMoteEmu
//****************************************************************************** //******************************************************************************
//wm_request_status global_struct;
//extern wm_request_status global_struct;
// =================================================== // ===================================================
/* Here we process the Output Reports that the Wii sends. Our response will be an Input Report /* Here we process the Output Reports that the Wii sends. Our response will be an Input Report
back to the Wii. Input and Output is from the Wii's perspective, Output means data to back to the Wii. Input and Output is from the Wii's perspective, Output means data to
the Wiimote (from the Wii), Input means data from the Wiimote. */ the Wiimote (from the Wii), Input means data from the Wiimote.
The call browser:
1. Wiimote_InterruptChannel > InterruptChannel > HidOutputReport
2. Wiimote_ControlChannel > ControlChannel > HidOutputReport */
// ---------------- // ----------------
void HidOutputReport(u16 _channelID, wm_report* sr) { void HidOutputReport(u16 _channelID, wm_report* sr) {
LOGV(WII_IPC_WIIMOTE, 0, "==========================================================="); LOGV(WII_IPC_WIIMOTE, 0, "===========================================================");
LOGV(WII_IPC_WIIMOTE, 0, "HidOutputReport(0x%02x)", sr->channel); LOGV(WII_IPC_WIIMOTE, 0, "HidOutputReport (0x%02x)", sr->channel);
switch(sr->channel) switch(sr->channel)
{ {
@ -95,6 +97,23 @@ void HidOutputReport(u16 _channelID, wm_report* sr) {
} }
// ===================================================
/* Generate the right address for wm reports. */
// ----------------
int WriteWmReport(u8* dst, u8 channel) {
u32 Offset = 0;
hid_packet* pHidHeader = (hid_packet*)(dst + Offset);
Offset += sizeof(hid_packet);
pHidHeader->type = HID_TYPE_DATA;
pHidHeader->param = HID_PARAM_INPUT;
wm_report* pReport = (wm_report*)(dst + Offset);
Offset += sizeof(wm_report);
pReport->channel = channel;
return Offset;
}
// =================================================== // ===================================================
/* LED (blue lights) report. */ /* LED (blue lights) report. */
// ---------------- // ----------------
@ -110,13 +129,18 @@ void WmLeds(u16 _channelID, wm_leds* leds) {
} }
void WmSendAck(u16 _channelID, u8 _reportID) // ===================================================
/* This will generate the 0x22 acknowledgment after all Input reports. It will
have the form a1 22 00 00 _reportID 00. The first two bytes are unknown but
00 00 seems to work fine. */
// ----------------
void WmSendAck(u16 _channelID, u8 _reportID, u32 address)
{ {
u8 DataFrame[1024]; u8 DataFrame[1024];
u32 Offset = 0; u32 Offset = 0;
// header // Header
hid_packet* pHidHeader = (hid_packet*)(DataFrame + Offset); hid_packet* pHidHeader = (hid_packet*)(DataFrame + Offset);
pHidHeader->type = HID_TYPE_DATA; pHidHeader->type = HID_TYPE_DATA;
pHidHeader->param = HID_PARAM_INPUT; pHidHeader->param = HID_PARAM_INPUT;
@ -130,8 +154,22 @@ void WmSendAck(u16 _channelID, u8 _reportID)
pData->errorID = 0; pData->errorID = 0;
Offset += sizeof(wm_acknowledge); Offset += sizeof(wm_acknowledge);
/* Debug. Write the report for extension registry writes.
if((_reportID == 0x16 || _reportID == 0x17) && ((address >> 16) & 0xfe) == 0xa4)
{
wprintf("\nWMSendAck Report ID: %02x KeyReady: %i, Encryption: %02x\n",
_reportID, (int)KeyReady, g_RegExt[0xf0]);
wprintf("Data: ");
for (int i = 0; i < Offset; i++)
{
wprintf("%02x ", DataFrame[i]);
if((i + 1) % 20 == 0) wprintf("\n");
}
wprintf("\n");
}*/
LOGV(WII_IPC_WIIMOTE, 2, " WMSendAck()"); LOGV(WII_IPC_WIIMOTE, 2, " WMSendAck()");
LOGV(WII_IPC_WIIMOTE, 2, " Report ID: %02x", _reportID);
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
} }
@ -151,6 +189,8 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
LOG(WII_IPC_WIIMOTE, " Size: 0x%04x", size); LOG(WII_IPC_WIIMOTE, " Size: 0x%04x", size);
LOG(WII_IPC_WIIMOTE, " Rumble: %x", rd->rumble); LOG(WII_IPC_WIIMOTE, " Rumble: %x", rd->rumble);
//u32 _address = address;
if(rd->space == 0) if(rd->space == 0)
{ {
if (address + size > WIIMOTE_EEPROM_SIZE) if (address + size > WIIMOTE_EEPROM_SIZE)
@ -218,7 +258,7 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
// Encrypt the read // Encrypt the read
wiimote_encrypt(&g_ExtKey, &g_RegExtTmp[address & 0xffff], (address & 0xffff), (u8)size); wiimote_encrypt(&g_ExtKey, &g_RegExtTmp[address & 0xffff], (address & 0xffff), (u8)size);
// Debugging /* Debugging
wprintf("\nEncrypted data:\n"); wprintf("\nEncrypted data:\n");
for (int i = 0; i < (u8)size; i++) for (int i = 0; i < (u8)size; i++)
{ {
@ -226,16 +266,16 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
if((i + 1) % 20 == 0) wprintf("\n"); if((i + 1) % 20 == 0) wprintf("\n");
} }
//wprintf("\ng_RegExtTmp after: \n"); wprintf("\ng_RegExtTmp after: \n");
//ReadExtTmp(); ReadExtTmp();
//wprintf("\nFrom g_RegExt: \n"); wprintf("\nFrom g_RegExt: \n");
//ReadExt(); ReadExt();*/
// Update the block that SendReadDataReply will eventually send to the Wii // Update the block that SendReadDataReply will eventually send to the Wii
block = g_RegExtTmp; block = g_RegExtTmp;
} }
wprintf("\n\n\n"); //wprintf("\n\n");
} }
//--------- //---------
@ -246,14 +286,17 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
return; return;
} }
// Let this function process the message and send it to the Wii
SendReadDataReply(_channelID, block+address, address, (u8)size); SendReadDataReply(_channelID, block+address, address, (u8)size);
} }
else else
{ {
PanicAlert("WmReadData: unimplemented parameters (size: %i, addr: 0x%x!", size, rd->space); PanicAlert("WmReadData: unimplemented parameters (size: %i, addr: 0x%x!", size, rd->space);
} }
// Acknowledge the 0x17 read, we will do this from InterruptChannel()
//WmSendAck(_channelID, WM_READ_DATA, _address);
LOGV(WII_IPC_WIIMOTE, 0, "==========================================================="); LOGV(WII_IPC_WIIMOTE, 0, "===========================================================");
} }
@ -272,6 +315,8 @@ void WmWriteData(u16 _channelID, wm_write_data* wd)
LOG(WII_IPC_WIIMOTE, " Size: 0x%02x", wd->size); LOG(WII_IPC_WIIMOTE, " Size: 0x%02x", wd->size);
LOG(WII_IPC_WIIMOTE, " Rumble: %x", wd->rumble); LOG(WII_IPC_WIIMOTE, " Rumble: %x", wd->rumble);
u32 _address = address;
// Write to EEPROM // Write to EEPROM
if(wd->size <= 16 && wd->space == WM_SPACE_EEPROM) if(wd->size <= 16 && wd->space == WM_SPACE_EEPROM)
{ {
@ -316,7 +361,7 @@ void WmWriteData(u16 _channelID, wm_write_data* wd)
// Remove for example 0xa40000 from the address // Remove for example 0xa40000 from the address
address &= 0xFFFF; _address = address; address &= 0xFFFF;
// Check if the address is within bounds // Check if the address is within bounds
if(address + wd->size > blockSize) { if(address + wd->size > blockSize) {
@ -332,8 +377,7 @@ void WmWriteData(u16 _channelID, wm_write_data* wd)
// ------------- // -------------
if(blockSize == WIIMOTE_REG_EXT_SIZE) if(blockSize == WIIMOTE_REG_EXT_SIZE)
{ {
// Debugging /* Debugging. Write the data.
// Write the data
wprintf("Data: "); wprintf("Data: ");
for (int i = 0; i < wd->size; i++) for (int i = 0; i < wd->size; i++)
{ {
@ -345,15 +389,13 @@ void WmWriteData(u16 _channelID, wm_write_data* wd)
//wprintf("Current address: %08x\n", address); //wprintf("Current address: %08x\n", address);
//wprintf("g_RegExt:\n"); //wprintf("g_RegExt:\n");
//ReadExt(); //ReadExt(); */
/* Run the key generation on all writes in the key area, it doesn't matter /* Run the key generation on all writes in the key area, it doesn't matter
that we send it parts of a key, only the last full key will have an that we send it parts of a key, only the last full key will have an
effect */ effect */
//if(address >= 0xa40040 && address <= 0xa4004c)
if(address >= 0x40 && address <= 0x4c) if(address >= 0x40 && address <= 0x4c)
//if(address == 0x4c)
wiimote_gen_key(&g_ExtKey, &g_RegExt[0x40]); wiimote_gen_key(&g_ExtKey, &g_RegExt[0x40]);
} }
// ------------- // -------------
@ -363,71 +405,85 @@ void WmWriteData(u16 _channelID, wm_write_data* wd)
PanicAlert("WmWriteData: unimplemented parameters!"); PanicAlert("WmWriteData: unimplemented parameters!");
} }
// just added for home brew.... hmmmm /* Just added for home brew... Isn't it enough that we call this from
WmSendAck(_channelID, WM_WRITE_DATA); InterruptChannel()? Or is there a separate route here that don't pass though
InterruptChannel()? */
//WmSendAck(_channelID, WM_WRITE_DATA, _address);
LOGV(WII_IPC_WIIMOTE, 0, "=========================================================="); LOGV(WII_IPC_WIIMOTE, 0, "==========================================================");
} }
// =================================================== // ===================================================
/* Generate the right address for wm reports. */ /* Here we produce the actual 0x21 Input report that we send to the Wii. The message
is divided into 16 bytes pieces and sent piece by piece. There will be five formatting
bytes at the begging of all reports. A common format is 00 00 f0 00 20, the 00 00
means that no buttons are pressedn, the f means 16 bytes in the message, the 0
means no error, the 00 20 means that the message is at the 00 20 offest the the
registry that was read. */
// ---------------- // ----------------
int WriteWmReport(u8* dst, u8 channel) { void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, u8 _Size)
u32 Offset = 0;
hid_packet* pHidHeader = (hid_packet*)(dst + Offset);
Offset += sizeof(hid_packet);
pHidHeader->type = HID_TYPE_DATA;
pHidHeader->param = HID_PARAM_INPUT;
wm_report* pReport = (wm_report*)(dst + Offset);
Offset += sizeof(wm_report);
pReport->channel = channel;
return Offset;
}
// Custom call version
void WmRequestStatus_(u16 _channelID, int a)
{ {
//PanicAlert("WmRequestStatus"); LOGV(WII_IPC_WIIMOTE, 0, "=========================================");
LOGV(WII_IPC_WIIMOTE, 0, "================================================"); int dataOffset = 0;
LOGV(WII_IPC_WIIMOTE, 0, " Request Status"); while (_Size > 0)
LOGV(WII_IPC_WIIMOTE, 0, " Channel: %04x", _channelID); {
//SendStatusReport();
u8 DataFrame[1024]; u8 DataFrame[1024];
u32 Offset = WriteWmReport(DataFrame, WM_STATUS_REPORT); u32 Offset = WriteWmReport(DataFrame, WM_READ_DATA_REPLY);
wm_status_report* pStatus = (wm_status_report*)(DataFrame + Offset); int copySize = _Size;
Offset += sizeof(wm_status_report); if (copySize > 16)
memset(pStatus, 0, sizeof(wm_status_report)); // fill the status report with zeroes
// Status values
pStatus->leds = g_Leds;
pStatus->ir = 1;
pStatus->battery = 0x4F; //arbitrary number
if(a == 1)
{ {
wprintf("pStatus->extension = 1\n"); copySize = 16;
pStatus->extension = 1;
}
else
{
wprintf("pStatus->extension = 0\n");
pStatus->extension = 0;
} }
wm_read_data_reply* pReply = (wm_read_data_reply*)(DataFrame + Offset);
Offset += sizeof(wm_read_data_reply);
pReply->buttons = 0;
pReply->error = 0;
pReply->size = (copySize - 1) & 0xF;
pReply->address = Common::swap16(_Address + dataOffset);
LOGV(WII_IPC_WIIMOTE, 0, " Extension: %x", pStatus->extension);
LOGV(WII_IPC_WIIMOTE, 0, " SendStatusReport()");
LOGV(WII_IPC_WIIMOTE, 0, " Flags: 0x%02x", pStatus->padding1[2]);
LOGV(WII_IPC_WIIMOTE, 0, " Battery: %d", pStatus->battery);
// Write a pice
memcpy(pReply->data + dataOffset, _Base, copySize);
if(copySize < 16) // check if we have less than 16 bytes left to send
{
memset(pReply->data + copySize, 0, 16 - copySize);
}
dataOffset += copySize;
LOG(WII_IPC_WIIMOTE, " SendReadDataReply()");
LOG(WII_IPC_WIIMOTE, " Buttons: 0x%04x", pReply->buttons);
LOG(WII_IPC_WIIMOTE, " Error: 0x%x", pReply->error);
LOG(WII_IPC_WIIMOTE, " Size: 0x%x", pReply->size);
LOG(WII_IPC_WIIMOTE, " Address: 0x%04x", pReply->address);
/* Debugging
wprintf("SendReadDataReply Address: %08x\n", _Address);
for (int i = 0; i < Offset; i++)
{
wprintf("%02x ", DataFrame[i]);
if((i + 1) % 25 == 0) wprintf("\n");
}
wprintf("\n\n");*/
//---------
// Send a piece
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset); g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
LOGV(WII_IPC_WIIMOTE, 0, "=================================================");
_Size -= copySize;
}
if (_Size != 0)
{
PanicAlert("WiiMote-Plugin: SendReadDataReply() failed");
}
LOGV(WII_IPC_WIIMOTE, 0, "==========================================");
} }
// ================
// =================================================== // ===================================================
@ -471,74 +527,4 @@ void WmRequestStatus(u16 _channelID, wm_request_status* rs)
LOGV(WII_IPC_WIIMOTE, 0, "================================================="); LOGV(WII_IPC_WIIMOTE, 0, "=================================================");
} }
// ===================================================
/* Here we produce the actual reply that we send to the Wii. The message is divided
into 16 bytes pieces and sent piece by piece. */
// ----------------
void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, u8 _Size)
{
LOGV(WII_IPC_WIIMOTE, 0, "=========================================");
int dataOffset = 0;
while (_Size > 0)
{
u8 DataFrame[1024];
u32 Offset = WriteWmReport(DataFrame, WM_READ_DATA_REPLY);
int copySize = _Size;
if (copySize > 16)
{
copySize = 16;
}
wm_read_data_reply* pReply = (wm_read_data_reply*)(DataFrame + Offset);
Offset += sizeof(wm_read_data_reply);
pReply->buttons = 0;
pReply->error = 0;
pReply->size = (copySize - 1) & 0xF;
pReply->address = Common::swap16(_Address + dataOffset);
// Write a pice
memcpy(pReply->data + dataOffset, _Base, copySize);
if(copySize < 16) // check if we have less than 16 bytes left to send
{
memset(pReply->data + copySize, 0, 16 - copySize);
}
dataOffset += copySize;
LOG(WII_IPC_WIIMOTE, " SendReadDataReply()");
LOG(WII_IPC_WIIMOTE, " Buttons: 0x%04x", pReply->buttons);
LOG(WII_IPC_WIIMOTE, " Error: 0x%x", pReply->error);
LOG(WII_IPC_WIIMOTE, " Size: 0x%x", pReply->size);
LOG(WII_IPC_WIIMOTE, " Address: 0x%04x", pReply->address);
// Debugging
/*
wprintf("SendReadDataReply\n");
for (int i = 0; i < sizeof(DataFrame); i++)
{
wprintf("%02x ", g_RegExt[i]);
if((i + 1) % 25 == 0) wprintf("\n");
}
wprintf("\n\n");
*/
//---------
// Send a piece
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
_Size -= copySize;
}
if (_Size != 0)
{
PanicAlert("WiiMote-Plugin: SendReadDataReply() failed");
}
LOGV(WII_IPC_WIIMOTE, 0, "==========================================");
}
} // end of namespace } // end of namespace

35
Source/Plugins/Plugin_Wiimote_Test/Src/EmuSubroutines.cpp
View File

@ -16,6 +16,27 @@
// http://code.google.com/p/dolphin-emu/ // http://code.google.com/p/dolphin-emu/
// ===================================================
/* HID reports access guide. */
// ----------------
/* 0x10 - 0x1a Output EmuMain.cpp: HidOutputReport()
0x10 - 0x14: General
0x15: Status report request from the Wii
0x16 and 0x17: Write and read memory or registers
0x19 and 0x1a: General
0x20 - 0x22 Input EmuMain.cpp: HidOutputReport() to the destination
0x15 leads to a 0x20 Input report
0x17 leads to a 0x21 Input report
0x10 - 0x1a leads to a 0x22 Input report
0x30 - 0x3f Input This file: Update() */
// ================
#include "pluginspecs_wiimote.h" #include "pluginspecs_wiimote.h"
#include <vector> #include <vector>
@ -27,8 +48,6 @@
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd #include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
extern SWiimoteInitialize g_WiimoteInitialize; extern SWiimoteInitialize g_WiimoteInitialize;
//extern void __Log(int log, const char *format, ...);
//extern void __Log(int log, int v, const char *format, ...);
namespace WiiMoteEmu namespace WiiMoteEmu
{ {
@ -142,7 +161,7 @@ void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
LOGV(WII_IPC_WIIMOTE, 0, "============================================================="); LOGV(WII_IPC_WIIMOTE, 0, "=============================================================");
const u8* data = (const u8*)_pData; const u8* data = (const u8*)_pData;
// dump raw data // Debugging. Dump raw data.
{ {
LOG(WII_IPC_WIIMOTE, "Wiimote_Input"); LOG(WII_IPC_WIIMOTE, "Wiimote_Input");
std::string Temp; std::string Temp;
@ -165,8 +184,16 @@ void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
case HID_PARAM_OUTPUT: case HID_PARAM_OUTPUT:
{ {
wm_report* sr = (wm_report*)hidp->data; wm_report* sr = (wm_report*)hidp->data;
WmSendAck(_channelID, sr->channel);
HidOutputReport(_channelID, sr); HidOutputReport(_channelID, sr);
/* This is the 0x22 answer to all Inputs. In most games it didn't matter
if it was written before or after HidOutputReport(), but Wii Sports
and Mario Galaxy would stop working if it was placed before
HidOutputReport(). */
wm_write_data *wd = (wm_write_data*)sr->data;
u32 address = convert24bit(wd->address);
WmSendAck(_channelID, sr->channel, address);
} }
break; break;

21
Source/Plugins/Plugin_Wiimote_Test/Src/EmuSubroutines.h
View File

@ -48,8 +48,6 @@ extern u8 g_Eeprom[WIIMOTE_EEPROM_SIZE];
extern u8 g_RegSpeaker[WIIMOTE_REG_SPEAKER_SIZE]; extern u8 g_RegSpeaker[WIIMOTE_REG_SPEAKER_SIZE];
extern u8 g_RegExt[WIIMOTE_REG_EXT_SIZE]; extern u8 g_RegExt[WIIMOTE_REG_EXT_SIZE];
extern u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE]; extern u8 g_RegExtTmp[WIIMOTE_REG_EXT_SIZE];
extern u8 g_RegExtBlnk[WIIMOTE_REG_EXT_SIZE];
extern u8 g_RegIr[WIIMOTE_REG_IR_SIZE]; extern u8 g_RegIr[WIIMOTE_REG_IR_SIZE];
extern u8 g_ReportingMode; extern u8 g_ReportingMode;
@ -57,6 +55,7 @@ extern u16 g_ReportingChannel;
extern wiimote_key g_ExtKey; // extension encryption key extern wiimote_key g_ExtKey; // extension encryption key
static const u8 EepromData_0[] = { static const u8 EepromData_0[] = {
0xA1, 0xAA, 0x8B, 0x99, 0xAE, 0x9E, 0x78, 0x30, 0xA1, 0xAA, 0x8B, 0x99, 0xAE, 0x9E, 0x78, 0x30,
0xA7, 0x74, 0xD3, 0xA1, 0xAA, 0x8B, 0x99, 0xAE, 0xA7, 0x74, 0xD3, 0xA1, 0xAA, 0x8B, 0x99, 0xAE,
@ -74,7 +73,8 @@ static const u8 EepromData_16D0[] = {
/* Default calibration for the nunchuck. It should be written to 0x20 - 0x3f of the /* Default calibration for the nunchuck. It should be written to 0x20 - 0x3f of the
extension register */ extension register. 0x80 is the neutral x and y accelerators and 0xb3 is the
neutral z accelerometer that is adjusted for gravity. */
static const u8 nunchuck_calibration[] = static const u8 nunchuck_calibration[] =
{ {
0x80,0x80,0x80,0x00, 0xb3,0xb3,0xb3,0x00, 0x80,0x80,0x80,0x00, 0xb3,0xb3,0xb3,0x00,
@ -89,7 +89,18 @@ static const u8 nunchuck_calibration[] =
static const u8 nunchuck_id[] = static const u8 nunchuck_id[] =
{ {
0x00, 0x00, 0xa4, 0x20, 0x00, 0x00 0x00, 0x00, 0xa4, 0x20, 0x00, 0x00
//0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/* The id for nothing inserted */
static const u8 nothing_id[] =
{
0x00, 0x00, 0x00, 0x00, 0x2e, 0x2e
};
/* The id for a partially inserted extension */
static const u8 partially_id[] =
{
0x00, 0x00, 0x00, 0x00, 0xff, 0xff
}; };
@ -110,7 +121,7 @@ void SendReportCoreAccelExt16(u16 _channelID);
void SendReportCoreAccelIr10Ext(u16 _channelID); void SendReportCoreAccelIr10Ext(u16 _channelID);
int WriteWmReport(u8* dst, u8 channel); int WriteWmReport(u8* dst, u8 channel);
void WmSendAck(u16 _channelID, u8 _reportID); void WmSendAck(u16 _channelID, u8 _reportID, u32 address);
void FillReportAcc(wm_accel& _acc); void FillReportAcc(wm_accel& _acc);

260
Source/Plugins/Plugin_Wiimote_Test/Src/FillReport.cpp
View File

@ -30,8 +30,6 @@
#include "Config.h" // for g_Config #include "Config.h" // for g_Config
extern SWiimoteInitialize g_WiimoteInitialize; extern SWiimoteInitialize g_WiimoteInitialize;
//extern void __Log(int log, const char *format, ...);
//extern void __Log(int log, int v, const char *format, ...);
namespace WiiMoteEmu namespace WiiMoteEmu
@ -68,13 +66,6 @@ void ReadExtTmp()
} }
/* The extension status can be a little difficult, this lets's us change the extension
status back and forth */
bool AllowReport = true;
int AllowCount = 0;
void FillReportInfo(wm_core& _core) void FillReportInfo(wm_core& _core)
{ {
memset(&_core, 0x00, sizeof(wm_core)); memset(&_core, 0x00, sizeof(wm_core));
@ -111,105 +102,28 @@ void FillReportInfo(wm_core& _core)
_core.right = GetAsyncKeyState(VK_RIGHT) ? 1 : 0; _core.right = GetAsyncKeyState(VK_RIGHT) ? 1 : 0;
_core.down = GetAsyncKeyState(VK_DOWN) ? 1 : 0; _core.down = GetAsyncKeyState(VK_DOWN) ? 1 : 0;
} }
/**/
// -----------------------
// Debugging. Send status report.
if(GetAsyncKeyState('I') && AllowReport)
{
//ClearScreen();
// Clear the register
//memcpy(g_RegExt, g_RegExtBlnk, sizeof(g_RegExt));
//g_RegExt[0xfc] = 0xa4;
//g_RegExt[0xfd] = 0x20;
// Clear the key part of the register
/**/
for(int i=0; i <= 16; i++)
{
g_RegExt[0x40 + i] = 0;
}
//wm_report sr;
//wm_request_status *sr;
//WmRequestStatus(g_ReportingChannel, sr);
/**/
WmRequestStatus_(g_ReportingChannel, 1);
wprintf("Sent status report\n");
AllowReport = false;
AllowCount = 0;
//void ReadExt();
}
/**/
if(GetAsyncKeyState('U') && AllowReport)
{
//ClearScreen();
//wm_report sr;
//wm_request_status *sr;
//WmRequestStatus(g_ReportingChannel, sr);
//memcpy(g_RegExt, g_RegExtBlnk, sizeof(g_RegExt));
//g_RegExt[0xfc] = 0xa4;
//g_RegExt[0xfd] = 0x20;
/**/
for(int i=0; i <= 16; i++)
{
g_RegExt[0x40 + i] = 0;
}
/* */
WmRequestStatus_(g_ReportingChannel, 0);
wprintf("Sent status report\n");
AllowReport = false;
AllowCount = 0;
//void ReadExt();
}
/**/
if(AllowCount > 10)
{
AllowReport = true;
AllowCount = 0;
}
AllowCount++;
// ----------
#else #else
// TODO: fill in // TODO: fill in
#endif #endif
} }
// ----------------------------- // -----------------------------
// Global declarations for FillReportAcc. The accelerometer x, y and z values range from /* Global declarations for FillReportAcc. The accelerometer x, y and z values range from
// 0x00 to 0xff with [y = 0x80, x = 0x80, z ~ 0xa0] being neutral and 0x00 being (-) 0x00 to 0xff with the default netural values being [y = 0x84, x = 0x84, z = 0x9f]
// and 0xff being (+). Or does it not? It's important that all values are not 0x80, according to a source. The extremes are 0x00 for (-) and 0xff for (+). It's important
// the the mouse pointer can disappear from the screen permanently, until z is adjusted that all values are not 0x80, the the mouse pointer can disappear from the screen
// back. permanently then, until z is adjusted back. */
// ---------- // ----------
// the variables are global so they can be changed during debugging // the variables are global so they can be changed during debugging
//int A = 0, B = 128, C = 64; // for debugging //int A = 0, B = 128, C = 64; // for debugging
//int a = 1, b = 1, c = 2, d = -2; // for debugging //int a = 1, b = 1, c = 2, d = -2; // for debugging
//int consoleDisplay = 0; //int consoleDisplay = 0;
int X = 0x84, Y = 0x84, Z = 0x9f; // neutral values
int X = 0x80, Y = 0x80, Z = 160; // neutral values u8 x = X, y = Y, z = Z;
u8 x = 0x0, y = 0x0, z = 0x00;
int shake = -1, yhistsize = 15; // for the shake function int shake = -1, yhistsize = 15; // for the shake function
std::vector<u8> yhist(15); // for the tilt function std::vector<u8> yhist(15); // for the tilt function
void FillReportAcc(wm_accel& _acc) void FillReportAcc(wm_accel& _acc)
{ {
#ifdef _WIN32 #ifdef _WIN32
@ -240,13 +154,11 @@ void FillReportAcc(wm_accel& _acc)
} }
// Single shake of Wiimote while holding it sideways (Wario Land pound ground) /* Single shake of Wiimote while holding it sideways (Wario Land pound ground)
/*
if(GetAsyncKeyState('S')) if(GetAsyncKeyState('S'))
z = 0; z = 0;
else else
z = Z; z = Z;*/
*/
if(GetAsyncKeyState('S')) if(GetAsyncKeyState('S'))
{ {
@ -266,6 +178,10 @@ void FillReportAcc(wm_accel& _acc)
y = Y; y = Y;
shake = -1; shake = -1;
} }
else // the default Y and Z if nothing is pressed
{
z = Z;
}
// ---------- // ----------
@ -288,7 +204,7 @@ void FillReportAcc(wm_accel& _acc)
if(!ypressed) // y was not pressed a single time if(!ypressed) // y was not pressed a single time
{ {
y = Y; y = Y; // this is the default value that will occur most of the time
//a = 0; // for debugging //a = 0; // for debugging
//b = 0; //b = 0;
} }
@ -319,7 +235,6 @@ void FillReportAcc(wm_accel& _acc)
consoleDisplay = 0; consoleDisplay = 0;
} }
if(GetAsyncKeyState('5')) if(GetAsyncKeyState('5'))
A-=1; A-=1;
else if(GetAsyncKeyState('6')) else if(GetAsyncKeyState('6'))
@ -332,18 +247,7 @@ void FillReportAcc(wm_accel& _acc)
C-=1; C-=1;
else if(GetAsyncKeyState('0')) else if(GetAsyncKeyState('0'))
C+=1; C+=1;
else if(GetAsyncKeyState(VK_INSERT))
a-=1;
else if(GetAsyncKeyState(VK_DELETE))
a+=1;
else if(GetAsyncKeyState(VK_HOME))
b-=1;
else if(GetAsyncKeyState(VK_END))
b+=1;
else if(GetAsyncKeyState(VK_SHIFT))
c-=1;
else if(GetAsyncKeyState(VK_CONTROL))
c+=1;
else if(GetAsyncKeyState(VK_NUMPAD3)) else if(GetAsyncKeyState(VK_NUMPAD3))
d-=1; d-=1;
else if(GetAsyncKeyState(VK_NUMPAD6)) else if(GetAsyncKeyState(VK_NUMPAD6))
@ -354,6 +258,20 @@ void FillReportAcc(wm_accel& _acc)
yhistsize+=1; yhistsize+=1;
/*if(GetAsyncKeyState(VK_INSERT))
AX-=1;
else if(GetAsyncKeyState(VK_DELETE))
AX+=1;
else if(GetAsyncKeyState(VK_HOME))
AY-=1;
else if(GetAsyncKeyState(VK_END))
AY+=1;
else if(GetAsyncKeyState(VK_SHIFT))
AZ-=1;
else if(GetAsyncKeyState(VK_CONTROL))
AZ+=1;*/
/*
if(GetAsyncKeyState(VK_NUMPAD1)) if(GetAsyncKeyState(VK_NUMPAD1))
X+=1; X+=1;
else if(GetAsyncKeyState(VK_NUMPAD2)) else if(GetAsyncKeyState(VK_NUMPAD2))
@ -367,49 +285,24 @@ void FillReportAcc(wm_accel& _acc)
else if(GetAsyncKeyState(VK_NUMPAD8)) else if(GetAsyncKeyState(VK_NUMPAD8))
Z-=1; Z-=1;
/*
if(GetAsyncKeyState('S'))
{
z = Z + C;
}
else
{
z = Z;
}
//if(consoleDisplay == 0)
if(GetAsyncKeyState('D')) wprintf("x: %03i | y: %03i | z: %03i | A:%i B:%i C:%i a:%i b:%i c:%i d:%i X:%i Y:%i Z:%i\n",
{ _acc.x, _acc.y, _acc.z,
y = Y + B;
}
else
{
y = Y;
}
if(GetAsyncKeyState('F'))
{
z = Z + C;
y = Y + B;
}
else if(!GetAsyncKeyState('S') && !GetAsyncKeyState('D'))
{
z = Z;
y = Y;
}
if(consoleDisplay == 0)
wprintf("x: %03i | y: %03i | z: %03i | A:%i B:%i C:%i a:%i b:%i c:%i d:%i X:%i Y:%i Z:%i\n", _acc.x, _acc.y, _acc.z,
A, B, C, A, B, C,
a, b, c, d, a, b, c, d,
X, Y, Z); X, Y, Z
*/ );
wprintf("x: %03i | y: %03i | z: %03i | X:%i Y:%i Z:%i | AX:%i AY:%i AZ:%i \n",
_acc.x, _acc.y, _acc.z,
X, Y, Z,
AX, AY, AZ
);*/
#else #else
// TODO port to linux // TODO port to linux
#endif #endif
} }
//bool toggleWideScreen = false, toggleCursor = true;
void FillReportIR(wm_ir_extended& _ir0, wm_ir_extended& _ir1) void FillReportIR(wm_ir_extended& _ir0, wm_ir_extended& _ir1)
{ {
@ -417,7 +310,6 @@ void FillReportIR(wm_ir_extended& _ir0, wm_ir_extended& _ir1)
/* DESCRIPTION: The calibration is controlled by these values, their absolute value and /* DESCRIPTION: The calibration is controlled by these values, their absolute value and
the relative distance between between them control the calibration. WideScreen mode the relative distance between between them control the calibration. WideScreen mode
has its own settings. */ has its own settings. */
/**/
int Top, Left, Right, Bottom, SensorBarRadius; int Top, Left, Right, Bottom, SensorBarRadius;
if(g_Config.bWideScreen) if(g_Config.bWideScreen)
{ {
@ -430,7 +322,7 @@ void FillReportIR(wm_ir_extended& _ir0, wm_ir_extended& _ir1)
Bottom = BOTTOM; SensorBarRadius = SENSOR_BAR_RADIUS; Bottom = BOTTOM; SensorBarRadius = SENSOR_BAR_RADIUS;
} }
// Fill with 0xff if empty
memset(&_ir0, 0xFF, sizeof(wm_ir_extended)); memset(&_ir0, 0xFF, sizeof(wm_ir_extended));
memset(&_ir1, 0xFF, sizeof(wm_ir_extended)); memset(&_ir1, 0xFF, sizeof(wm_ir_extended));
@ -451,7 +343,7 @@ void FillReportIR(wm_ir_extended& _ir0, wm_ir_extended& _ir1)
_ir0.yHi = y0 >> 8; _ir0.yHi = y0 >> 8;
x1 = 1023 - x1; x1 = 1023 - x1;
_ir1.x = x1; _ir1.x = x1 & 0xFF;
_ir1.y = y1 & 0xFF; _ir1.y = y1 & 0xFF;
_ir1.size = 10; _ir1.size = 10;
_ir1.xHi = x1 >> 8; _ir1.xHi = x1 >> 8;
@ -488,13 +380,20 @@ void FillReportIR(wm_ir_extended& _ir0, wm_ir_extended& _ir1)
wprintf("x0:%03i x1:%03i y0:%03i y1:%03i irx0:%03i y0:%03i x1:%03i y1:%03i | T:%i L:%i R:%i B:%i S:%i\n", wprintf("x0:%03i x1:%03i y0:%03i y1:%03i irx0:%03i y0:%03i x1:%03i y1:%03i | T:%i L:%i R:%i B:%i S:%i\n",
x0, x1, y0, y1, _ir0.x, _ir0.y, _ir1.x, _ir1.y, Top, Left, Right, Bottom, SensorBarRadius x0, x1, y0, y1, _ir0.x, _ir0.y, _ir1.x, _ir1.y, Top, Left, Right, Bottom, SensorBarRadius
); );
*/ wprintf("\n");
wprintf("ir0.x:%02x xHi:%02x ir1.x:%02x xHi:%02x | ir0.y:%02x yHi:%02x ir1.y:%02x yHi:%02x | 1.s:%02x 2:%02x\n",
_ir0.x, _ir0.xHi, _ir1.x, _ir1.xHi,
_ir0.y, _ir0.yHi, _ir1.y, _ir1.yHi,
_ir0.size, _ir1.size
);*/
} }
void FillReportIRBasic(wm_ir_basic& _ir0, wm_ir_basic& _ir1) void FillReportIRBasic(wm_ir_basic& _ir0, wm_ir_basic& _ir1)
{ {
/* See description above */ /* See description above */
int Top, Left, Right, Bottom, SensorBarRadius; int Top, Left, Right, Bottom, SensorBarRadius;
if(g_Config.bWideScreen) if(g_Config.bWideScreen)
{ {
Top = wTOP; Left = wLEFT; Right = wRIGHT; Top = wTOP; Left = wLEFT; Right = wRIGHT;
@ -506,8 +405,9 @@ void FillReportIRBasic(wm_ir_basic& _ir0, wm_ir_basic& _ir1)
Bottom = BOTTOM; SensorBarRadius = SENSOR_BAR_RADIUS; Bottom = BOTTOM; SensorBarRadius = SENSOR_BAR_RADIUS;
} }
memset(&_ir0, 0xFF, sizeof(wm_ir_basic)); // Fill with 0xff if empty
memset(&_ir1, 0xFF, sizeof(wm_ir_basic)); memset(&_ir0, 0xff, sizeof(wm_ir_basic));
memset(&_ir1, 0xff, sizeof(wm_ir_basic));
float MouseX, MouseY; float MouseX, MouseY;
GetMousePos(MouseX, MouseY); GetMousePos(MouseX, MouseY);
@ -518,17 +418,23 @@ void FillReportIRBasic(wm_ir_basic& _ir0, wm_ir_basic& _ir1)
int x1 = Left + (MouseX * (Right - Left)) - SensorBarRadius; int x1 = Left + (MouseX * (Right - Left)) - SensorBarRadius;
int x2 = Left + (MouseX * (Right - Left)) + SensorBarRadius; int x2 = Left + (MouseX * (Right - Left)) + SensorBarRadius;
/* As with the extented report we settle with emulating two out of four
possible objects */
x1 = 1023 - x1; x1 = 1023 - x1;
_ir0.x1 = x1 & 0xFF; _ir0.x1 = x1 & 0xff;
_ir0.y1 = y1 & 0xFF; _ir0.y1 = y1 & 0xff;
_ir0.x1Hi = (x1 >> 8) & 0x3; _ir0.x1Hi = (x1 >> 8); // we are dealing with 2 bit values here
_ir0.y1Hi = (y1 >> 8) & 0x3; _ir0.y1Hi = (y1 >> 8);
x2 = 1023 - x2; x2 = 1023 - x2;
_ir1.x2 = x2 & 0xFF; _ir0.x2 = x2 & 0xff;
_ir1.y2 = y2 & 0xFF; _ir0.y2 = y2 & 0xff;
_ir1.x2Hi = (x2 >> 8) & 0x3; _ir0.x2Hi = (x2 >> 8);
_ir1.y2Hi = (y2 >> 8) & 0x3; _ir0.y2Hi = (y2 >> 8);
// I don't understand't the & 0x03, should we do that?
//_ir1.x1Hi = (x1 >> 8) & 0x3;
//_ir1.y1Hi = (y1 >> 8) & 0x3;
// ---------------------------- // ----------------------------
// Debugging for calibration // Debugging for calibration
@ -557,46 +463,50 @@ void FillReportIRBasic(wm_ir_basic& _ir0, wm_ir_basic& _ir1)
//ClearScreen(); //ClearScreen();
//if(consoleDisplay == 1) //if(consoleDisplay == 1)
wprintf("x1:%03i x2:%03i y1:%03i y2:%03i irx1:%03i y1:%03i x2:%03i y2:%03i | T:%i L:%i R:%i B:%i S:%i\n",
wprintf("x1:%03i x2:%03i y1:%03i y2:%03i irx1:%02x y1:%02x x2:%02x y2:%02x | T:%i L:%i R:%i B:%i S:%i\n",
x1, x2, y1, y2, _ir0.x1, _ir0.y1, _ir1.x2, _ir1.y2, Top, Left, Right, Bottom, SensorBarRadius x1, x2, y1, y2, _ir0.x1, _ir0.y1, _ir1.x2, _ir1.y2, Top, Left, Right, Bottom, SensorBarRadius
);
wprintf("\n");
wprintf("ir0.x1:%02x x1h:%02x x2:%02x x2h:%02x | ir0.y1:%02x y1h:%02x y2:%02x y2h:%02x | ir1.x1:%02x x1h:%02x x2:%02x x2h:%02x | ir1.y1:%02x y1h:%02x y2:%02x y2h:%02x\n",
_ir0.x1, _ir0.x1Hi, _ir0.x2, _ir0.x2Hi,
_ir0.y1, _ir0.y1Hi, _ir0.y2, _ir0.y2Hi,
_ir1.x1, _ir1.x1Hi, _ir1.x2, _ir1.x2Hi,
_ir1.y1, _ir1.y1Hi, _ir1.y2, _ir1.y2Hi
);*/ );*/
} }
// =================================================== // ===================================================
/* Generate the 6 byte extension report, encrypted. */ /* Generate the 6 byte extension report, encrypted. The bytes are JX JY AX AY AZ BT. */
// ---------------- // ----------------
void FillReportExtension(wm_extension& _ext) void FillReportExtension(wm_extension& _ext)
{ {
// JX JY AX AY AZ BT
// Make temporary values
/* These are the default neutral values for the nunchuck accelerometer according
to a source. */
_ext.ax = 0x80; _ext.ax = 0x80;
_ext.ay = 0x80; _ext.ay = 0x80;
_ext.az = 0xb3; _ext.az = 0xb3;
_ext.jx = 0x80; // these are the default values unless we don't use them _ext.jx = 0x80; // these are the default values unless we use them
_ext.jy = 0x80; _ext.jy = 0x80;
_ext.bt = 0x03; // 0x03 means no button pressed, the button is zero active _ext.bt = 0x03; // 0x03 means no button pressed, the button is zero active
#ifdef _WIN32 #ifdef _WIN32
if(GetAsyncKeyState(VK_NUMPAD4)) if(GetAsyncKeyState(VK_NUMPAD4))
_ext.jx = 0x20; _ext.jx = 0x20;
if(GetAsyncKeyState(VK_NUMPAD8)) if(GetAsyncKeyState(VK_NUMPAD8))
_ext.jy = 0x20; _ext.jy = 0xe0;
if(GetAsyncKeyState(VK_NUMPAD6)) if(GetAsyncKeyState(VK_NUMPAD6))
_ext.jx = 0xe0; _ext.jx = 0xe0;
if(GetAsyncKeyState(VK_NUMPAD5)) if(GetAsyncKeyState(VK_NUMPAD5))
_ext.jy = 0xe0; _ext.jy = 0x20;
@ -612,8 +522,8 @@ void FillReportExtension(wm_extension& _ext)
// TODO linux port // TODO linux port
#endif #endif
// Clear g_RegExtTmp by copying g_RegExtBlnk to g_RegExtTmp // Clear g_RegExtTmp by copying zeroes to it
memcpy(g_RegExtTmp, g_RegExtBlnk, sizeof(g_RegExt)); memset(g_RegExtTmp, 0, sizeof(g_RegExtTmp));
// Write the nunchuck inputs to it // Write the nunchuck inputs to it
g_RegExtTmp[0x08] = _ext.jx; g_RegExtTmp[0x08] = _ext.jx;
@ -636,8 +546,4 @@ void FillReportExtension(wm_extension& _ext)
} }
} // end of namespace } // end of namespace

6
Source/Plugins/Plugin_Wiimote_Test/Src/main.cpp
View File

@ -164,7 +164,7 @@ extern "C" void Wiimote_InterruptChannel(u16 _channelID, const void* _pData, u32
LOGV(WII_IPC_WIIMOTE, 0, "============================================================="); LOGV(WII_IPC_WIIMOTE, 0, "=============================================================");
const u8* data = (const u8*)_pData; const u8* data = (const u8*)_pData;
// dump raw data // Debugging. Dump raw data.
{ {
LOG(WII_IPC_WIIMOTE, "Wiimote_Input"); LOG(WII_IPC_WIIMOTE, "Wiimote_Input");
LOG(WII_IPC_WIIMOTE, " Channel ID: %04x", _channelID); LOG(WII_IPC_WIIMOTE, " Channel ID: %04x", _channelID);
@ -222,6 +222,9 @@ extern "C" unsigned int Wiimote_GetAttachedControllers()
} }
// ===================================================
/* Logging functions. */
// ----------------
void __Log(int log, const char *_fmt, ...) void __Log(int log, const char *_fmt, ...)
{ {
char Msg[512]; char Msg[512];
@ -246,3 +249,4 @@ void __Logv(int log, int v, const char *_fmt, ...)
g_WiimoteInitialize.pLog(Msg, v); g_WiimoteInitialize.pLog(Msg, v);
} }
// ================

18
Source/Plugins/Plugin_Wiimote_Test/Src/wiimote_hid.h
View File

@ -167,6 +167,14 @@ struct wm_ir_basic
u8 y2; u8 y2;
}; };
struct wm_ir_extended
{
u8 x;
u8 y;
u8 size : 4;
u8 xHi : 2;
u8 yHi : 2;
};
struct wm_extension struct wm_extension
{ {
@ -178,16 +186,6 @@ struct wm_extension
u8 bt; // buttons u8 bt; // buttons
}; };
struct wm_ir_extended
{
u8 x;
u8 y;
u8 size : 4;
u8 xHi : 2;
u8 yHi : 2;
};
#define WM_REPORT_CORE 0x30 #define WM_REPORT_CORE 0x30
struct wm_report_core { struct wm_report_core {
wm_core c; wm_core c;