WiimoteWindows::WiimoteWindows(const std::basic_string<TCHAR>& path) : m_devicepath(path)
{
m_dev_handle = 0;
m_stack = MSBT_STACK_UNKNOWN;
m_hid_overlap_read = OVERLAPPED();
m_hid_overlap_read.hEvent = CreateEvent(nullptr, true, false, nullptr);
m_hid_overlap_write = OVERLAPPED();
m_hid_overlap_write.hEvent = CreateEvent(nullptr, true, false, nullptr);
}
void Wiimote::InitInternal()
{
dev_handle = 0;
stack = MSBT_STACK_UNKNOWN;
hid_overlap_read = OVERLAPPED();
hid_overlap_read.hEvent = CreateEvent(nullptr, true, false, nullptr);
hid_overlap_write = OVERLAPPED();
hid_overlap_write.hEvent = CreateEvent(nullptr, true, false, nullptr);
}
WiimoteWindows::WiimoteWindows(const std::basic_string<TCHAR>& path,
WinWriteMethod initial_write_method)
: m_devicepath(path), m_write_method(initial_write_method)
{
m_dev_handle = nullptr;
m_hid_overlap_read = OVERLAPPED();
m_hid_overlap_read.hEvent = CreateEvent(nullptr, true, false, nullptr);
m_hid_overlap_write = OVERLAPPED();
m_hid_overlap_write.hEvent = CreateEvent(nullptr, true, false, nullptr);
}
~locked_file()
{
if(h_==INVALID_HANDLE_VALUE)
return;
OVERLAPPED ov = OVERLAPPED();
::UnlockFileEx(h_,0,0,16,&ov);
::CloseHandle(h_);
}
static int ReadFromHandle(HANDLE& dev_handle, u8* buf)
{
OVERLAPPED hid_overlap_read = OVERLAPPED();
hid_overlap_read.hEvent = CreateEvent(nullptr, true, false, nullptr);
const int read = IORead(dev_handle, hid_overlap_read, buf, 1);
CloseHandle(hid_overlap_read.hEvent);
return read;
}
static int WriteToHandle(HANDLE& dev_handle, WinWriteMethod& method, const u8* buf, size_t size)
{
OVERLAPPED hid_overlap_write = OVERLAPPED();
hid_overlap_write.hEvent = CreateEvent(nullptr, true, false, nullptr);
DWORD written = 0;
IOWrite(dev_handle, hid_overlap_write, method, buf, size, &written);
CloseHandle(hid_overlap_write.hEvent);
return written;
}
void FileWatcherWin32::run()
{
if ( mHandles.empty() )
{
return;
}
do
{
if ( !mHandles.empty() )
{
mWatchesLock.lock();
for ( std::size_t i = 0; i < mWatches.size(); i++ )
{
WatcherStructWin32 * watch = mWatches[ i ];
// If the overlapped struct was cancelled ( because the creator thread doesn't exists anymore ),
// we recreate the overlapped in the current thread and refresh the watch
if ( /*STATUS_CANCELED*/0xC0000120 == watch->Overlapped.Internal )
{
watch->Overlapped = OVERLAPPED();
RefreshWatch(watch);
}
// First ensure that the handle is the same, this means that the watch was not removed.
if ( HasOverlappedIoCompleted( &watch->Overlapped ) && mHandles[ i ] == watch->Watch->DirHandle )
{
DWORD bytes;
if ( GetOverlappedResult( watch->Watch->DirHandle, &watch->Overlapped, &bytes, FALSE ) )
{
WatchCallback( ERROR_SUCCESS, bytes, &watch->Overlapped );
}
}
}
mWatchesLock.unlock();
if ( mInitOK )
{
System::sleep( 10 );
}
}
else
{
// Wait for a new handle to be added
System::sleep( 10 );
}
} while ( mInitOK );
}
int CheckDeviceType_Read(HANDLE &dev_handle, u8* buf, int attempts)
{
OVERLAPPED hid_overlap_read = OVERLAPPED();
hid_overlap_read.hEvent = CreateEvent(nullptr, true, false, nullptr);
int read = 0;
for (; attempts>0; --attempts)
{
read = _IORead(dev_handle, hid_overlap_read, buf, 1);
if (read > 0)
break;
}
CloseHandle(hid_overlap_read.hEvent);
return read;
}
int CheckDeviceType_Write(HANDLE &dev_handle, const u8* buf, size_t size, int attempts)
{
OVERLAPPED hid_overlap_write = OVERLAPPED();
hid_overlap_write.hEvent = CreateEvent(nullptr, true, false, nullptr);
enum win_bt_stack_t stack = MSBT_STACK_UNKNOWN;
DWORD written = 0;
for (; attempts>0; --attempts)
{
if (_IOWrite(dev_handle, hid_overlap_write, stack, buf, size, &written))
break;
}
CloseHandle(hid_overlap_write.hEvent);
return written;
}
locked_file(session_file_storage *object,std::string sid) :
h_(INVALID_HANDLE_VALUE)
{
name_=object->file_name(sid);
int sleep_time=0;
for(;;) {
h_=::CreateFileW(booster::nowide::convert(name_).c_str(),
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if(h_==INVALID_HANDLE_VALUE) {
if(GetLastError()==ERROR_ACCESS_DENIED && sleep_time<1000 ) {
::Sleep(sleep_time);
sleep_time = sleep_time == 0 ? 1 : sleep_time * 2;
continue;
}
else {
std::ostringstream tmp;
tmp << "Failed to open file:" + name_ + "error code " <<std::hex << ::GetLastError();
throw cppcms_error(tmp.str());
}
}
else
break;
}
OVERLAPPED ov = OVERLAPPED();
if(!::LockFileEx(h_,LOCKFILE_EXCLUSIVE_LOCK,0,0,16,&ov)) {
::CloseHandle(h_);
h_=INVALID_HANDLE_VALUE;
throw cppcms_error("Failed to lock file:"+name_);
}
}
void UsbInterfacePrivate::threadFunc()
{
HANDLE handles[1+m_oCount];
handles[0] = m_quitEvent;
handles[m_oCount] = m_waitEvents[m_oCount-1];
//= { m_quitEvent, m_waitEvents[0], m_waitEvents[1] };
// start first read operation
for (m_readIdx = 0 ; m_readIdx < (m_oCount-1); ++m_readIdx)
{
handles[m_readIdx+1] = m_waitEvents[m_readIdx];
//m_readIdx = 0;
m_overlapped[m_readIdx] = OVERLAPPED();
::ResetEvent(m_waitEvents[m_readIdx]); //lint !e534
m_overlapped[m_readIdx].hEvent = m_waitEvents[m_readIdx];
m_winUsb.ReadPipe(m_usbHandle[1],
m_bulkInPipe,
m_fixedBuffer[m_readIdx],
(ULONG)m_fixedBufferSize,
0,
&m_overlapped[m_readIdx]); //lint !e534
}
int fastCount = 0;
//m_readIdx = 1;
bool policyFast = false;
bool run = true;
while (run)
{
// start follow-up read operation
m_overlapped[m_readIdx] = OVERLAPPED();
::ResetEvent(m_waitEvents[m_readIdx]); //lint !e534
m_overlapped[m_readIdx].hEvent = m_waitEvents[m_readIdx];
m_winUsb.ReadPipe(m_usbHandle[1],
m_bulkInPipe,
m_fixedBuffer[m_readIdx],
(ULONG)m_fixedBufferSize,
0,
&m_overlapped[m_readIdx]); //lint !e534
m_readIdx = (m_readIdx + 1) % m_oCount;
int64_t tBegin = XsTime_timeStampNow(0);
DWORD waitResult = ::WaitForMultipleObjects(1+m_oCount, handles, FALSE, INFINITE);
#if 0 // not sure if this causes problems, but it should help in catching up
int64_t tEnd = XsTime_timeStampNow(0);
switch (tEnd - tBegin)
{
case 0:
if (++fastCount > m_fastPolicyThreshold && !policyFast)
{
policyFast = true;
// set fast policy
UCHAR enable = TRUE;
m_winUsb.SetPipePolicy(m_usbHandle[1], m_bulkInPipe, IGNORE_SHORT_PACKETS, sizeof(UCHAR), &enable); //lint !e534
}
break;
case 1:
if (fastCount)
--fastCount;
if (policyFast && fastCount <= m_fastPolicyThreshold)
{
// reset policy
policyFast = false;
UCHAR enable = FALSE;
m_winUsb.SetPipePolicy(m_usbHandle[1], m_bulkInPipe, IGNORE_SHORT_PACKETS, sizeof(UCHAR), &enable); //lint !e534
}
break;
default:
fastCount = 0;
if (policyFast)
{
// reset policy
policyFast = false;
UCHAR enable = FALSE;
m_winUsb.SetPipePolicy(m_usbHandle[1], m_bulkInPipe, IGNORE_SHORT_PACKETS, sizeof(UCHAR), &enable); //lint !e534
}
break;
}
#endif
// handle data
switch (waitResult)
{
case WAIT_TIMEOUT:
case WAIT_FAILED:
case WAIT_OBJECT_0:
run = false;
break;
default:
if (waitResult >= WAIT_ABANDONED_0)
{
JLDEBUG(gJournal, "WFMO abandoned: " << (waitResult - WAIT_OBJECT_0));
break;
}
#ifndef XSENS_RELEASE
JLDEBUG(gJournal, "WFMO trigger: " << (waitResult - WAIT_OBJECT_0));
#endif
{
// put data into buffer
int idx = m_readIdx;
DWORD dataRead = 0;
if (!m_winUsb.GetOverlappedResult(m_usbHandle[0], &m_overlapped[idx], &dataRead, FALSE))
{
// error
DWORD err = ::GetLastError();
switch (err)
{
case ERROR_SEM_TIMEOUT:
case ERROR_IO_INCOMPLETE:
//JLDEBUG(gJournal, "m_winUsb.GetOverlappedResult resulted in acceptable windows error " << err);
break;
default:
JLALERT(gJournal, "m_winUsb.GetOverlappedResult resulted in windows error " << err);
run = false;
break;
}
//assert (err == ERROR_IO_INCOMPLETE);
}
else
{
// append unread data to var buffer
JLTRACE(gJournal, "m_winUsb.GetOverlappedResult resulted in " << dataRead << " bytes being read");
XsByteArray ref(&m_fixedBuffer[idx][0], dataRead, XSDF_None);
::EnterCriticalSection(&m_mutex);
m_varBuffer.append(ref);
::LeaveCriticalSection(&m_mutex);
}
} break;
}
}
}
/*
FUNCTION: WndProc
DATE: 12/2/2015
REVISIONS: v3 - changed all IO operations to overlapped
DESIGNER: Dylan & Allen & Thomas
PROGRAMMER: Dylan & Allen
INTERFACE: LRESULT CALLBACK WndProc (HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
HWND hwnd : handle to the the main window
UINT Message : message sent from the message loop to the window
WPARAM wParam : parameters to the message
LPARAM lParam : parameters to the message
RETURNS: The default window procedure or 0
NOTES: Handles all button presses from the main window as well as
events from the serial port reading thread
*/
LRESULT CALLBACK WndProc (HWND hwnd, UINT Message,
WPARAM wParam, LPARAM lParam)
{
switch (Message)
{
case WM_CREATE:
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case ASN_ENQ:
if (state != IDLE && state != WAIT) {
OutputDebugString("ENQ but not idling\n");
break;
}
startWriting();
// send ENQ to the serial port and assume it never fails
WriteFile(hComm, enq, 1, NULL, &OVERLAPPED());
state = WENQACK;
OutputDebugString("ENQ sent\n");
finishWriting();
break;
case ASN_SET:
startWriting();
if (!CommConfigDialog(TEXT("com1"), hMain, &cc)) {
return FALSE;
}
else {
SetCommConfig(hComm, &cc, cc.dwSize);
PurgeComm(hComm, PURGE_RXCLEAR);
}
finishWriting();
break;
case ASN_CON:
OpenFileDialog();
break;
case ASN_CLR:
ClearTextBoxes();
break;
case ASN_QUIT:
PostQuitMessage(0);
break;
case ASN_HLP:
break;
case ASN_OPN:
OpenFileDialog();
break;
case ACK_REC:
if (state != WACK && state != WENQACK) {
OutputDebugString("ACK received but not waiting for ACK before sending a packet\n");
break;
}
if (state == WENQACK) {
OutputDebugString("ACK received\n");
acksReceived++;
SetStatistics();
if (packetBuffer[currentPacket][0] != 0) {
OVERLAPPED overlapped = { 0 };
overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
startWriting();
if (!WriteFile(hComm, packetBuffer[currentPacket++], PACKETLENGTH, NULL, &overlapped)) {
WaitForSingleObject(overlapped.hEvent, TIMEOUT);
}
OutputDebugString("Sent a packet\n");
packetsSent++;
SetStatistics();
// ENQ the line to send the next packet
// THIS SHOULD BE REPLACED BY THE APPROPRIATE PRIORTIY PROTOCOL
/*
if (packetBuffer[currentPacket][0] != 0) {
WriteFile(hComm, enq, 1, NULL, NULL);
}
*/
finishWriting();
}
OutputDebugString("Going to WACK state\n");
state = WACK;
break;
}
if (state == WACK) {
OutputDebugString("Packet confirmed received\n");
OutputDebugString("Going to WAIT state\n");
state = WAIT;
packsAcked++;
acksReceived++;
SetStatistics();
}
break;
}
break; // end WM_COMMAND
case WM_CHAR:
break;
case WM_SIZE:
break;
case WM_DESTROY: // Terminate program
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, Message, wParam, lParam);
}
return 0;
}
