void Connection::sendData(const Buffer *buffer) { std::cout << "Connection::sendData" << std::endl; std::cout << std::to_string(_isSending) << " - " << _sendQueue.size() << std::endl; _sendQueue.push_back(buffer); startWriting(); }
void K3b::Iso9660ImageWritingJob::start() { d->canceled = d->finished = false; d->currentCopy = 1; jobStarted(); if( m_simulate ) m_verifyData = false; emit newTask( i18n("Preparing data") ); if( !QFile::exists( m_imagePath ) ) { emit infoMessage( i18n("Could not find image %1", m_imagePath), K3b::Job::MessageError ); jobFinished( false ); return; } KIO::filesize_t mb = K3b::imageFilesize( m_imagePath )/1024ULL/1024ULL; // very rough test but since most dvd images are 4,x or 8,x GB it should be enough d->isDvdImage = ( mb > 900ULL ); startWriting(); }
void Connection::internOnDataWritten(const boost::system::error_code &ec, std::size_t bytesTransferred) { std::cout << "Connection::internOnDataWritten" << std::endl; _isSending = false; //TODO mutex ? if (!ec) { _sendQueue.erase(_sendQueue.begin()); onDataWritten(bytesTransferred); if (_sendQueue.size() > 0) { startWriting(); } } else { //if we are closing -> ignore error if (!_isClosing) { internOnError(ec, ERROR_SOURCE_WRITE); } } }
/******************************************************************************* * Name of Function: writerHandler * Purpose: writes the writer output file till maximum item * Parameters: pointer to arguments as void * Return Value: void * Calls to: startWriting, writeData, finishWriting * Called from: main * Method: 1. get mutually exclusive access to writer output file * 2. writes 5 items * 3. release the shared writer file * 4. repeats this process till max iteration(20) for each * writer ******************************************************************************/ void *writerHandler (void *args) { struct writer_struct *writer; int i; writer = (struct writer_struct *)args; /* write till max iterations for each writer */ for(i=1;i<=MAX_ITERATIONS;i++) { printf("%ld W%d waiting-for-lock\n", timeElapsed(), writer->w_id); startWriting(writer->monitor, writer->w_id); printf("%ld W%d lock-acquired\n", timeElapsed(), writer->w_id); writeData(writer->w_id, &(writer->w_item)); finishWriting(writer->monitor); printf("%ld W%d lock-released\n",timeElapsed(), writer->w_id); } return; }
/* FUNCTION: ReadFromPort DATE: 11/28/2015 REVISIONS: v4 12/2/2015 - wait state added DESIGNER: Allen & Dylan & Thomas PROGRAMMER: Allen & Dylan INTERFACE: static DWORD WINAPI ReadFromPort(LPVOID lpParam) LPVOID lpParam : parameter passed to the thread; intended to be a communications handle RETURNS: 1 NOTES: This function is intended to be called on a separate thread. It has the event driven code to monitor the serial port for INCOMING communications. It will send messages to the main window (via WndProc) for OUTGOING communications. */ static DWORD WINAPI ReadFromPort(LPVOID lpParam) { OVERLAPPED overlapped = { 0 }; HANDLE hnd = 0; BOOL fWaitingOnRead = FALSE; overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); CHAR buffer[PACKETLENGTH] = ""; DWORD dwEvent; SetCommMask(lpParam, EV_RXCHAR); while (true) { switch (state) { // Waiting for ENQ ACKnowledgment case WENQACK: if (!fWaitingOnRead) { if (!WaitCommEvent(lpParam, &dwEvent, &overlapped)) { if (GetLastError() == ERROR_IO_PENDING) { fWaitingOnRead = TRUE; } } } else { if (Wait(overlapped.hEvent, TIMEOUT)) { if (!ReadFile(lpParam, buffer, 1, NULL, &overlapped)) { WaitForSingleObject(overlapped.hEvent, TIMEOUT); }; OutputDebugString("Finished reading in WENQACK\n"); if (buffer[0] == ACK) { SendMessage(hMain, WM_COMMAND, ACK_REC, NULL); } else { OutputDebugString("Was not ACK, was "); OutputDebugString(buffer); OutputDebugString("\n"); state = WAIT; } fWaitingOnRead = FALSE; } else { state = IDLE; } } break; // Waiting for ACKnowledgment for a packet case WACK: if (!fWaitingOnRead) { if (!WaitCommEvent(lpParam, &dwEvent, &overlapped)) { if (GetLastError() == ERROR_IO_PENDING) { fWaitingOnRead = TRUE; } } } else { if (Wait(overlapped.hEvent, TIMEOUT)) { ReadFile(lpParam, &buffer, 1, NULL, &overlapped); if (buffer[0] == ACK) { SendMessage(hMain, WM_COMMAND, ACK_REC, NULL); buffer[0] = 0; } fWaitingOnRead = FALSE; } else { state = WAIT; } } break; // a backoff state, can only become a receiver for some time case WAIT: // default state, can move to sending or receiving case IDLE: if (!fWaitingOnRead) { if ((state == WAIT || state == IDLE) && !WaitCommEvent(lpParam, &dwEvent, &overlapped)) { if (GetLastError() == ERROR_IO_PENDING) { fWaitingOnRead = TRUE; } } } else { if ((state == WAIT || state == IDLE) && Wait(overlapped.hEvent, TIMEOUT)) { ReadFile(lpParam, &buffer, 1, NULL, &overlapped); if (buffer[0] == ENQ) { startWriting(); SendAck(lpParam); finishWriting(); state = RECEIVING; } // this is what you call a hack to get around race conditions else if ((state == WENQACK || state == WACK) && buffer[0] == ACK) { SendMessage(hMain, WM_COMMAND, ACK_REC, NULL); } fWaitingOnRead = FALSE; } else { state = IDLE; } } break; // anticipating a packet case RECEIVING: if (!fWaitingOnRead) { if (!WaitCommEvent(lpParam, &dwEvent, &overlapped)) { if (GetLastError() == ERROR_IO_PENDING) { fWaitingOnRead = TRUE; } } } else { if (Wait(overlapped.hEvent, INFINITE)) { receiveBuffer = ReceivePacket(lpParam, overlapped); if (ErrorCheck(receiveBuffer) || 1) { //DoNonReadingStuff(receiveBuffer); Depacketize(receiveBuffer); startWriting(); SendAck(lpParam); finishWriting(); packetsReceived++; SetStatistics(); // open the file for writing and reading hnd = CreateFile(FileName, FILE_APPEND_DATA | GENERIC_WRITE | GENERIC_READ, NULL, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); startWriting(); if (WritePacketToFile(receiveBuffer, hnd)) { UpdateWindowFromFile(hReceive, hnd); } finishWriting(); CloseHandle(hnd); fWaitingOnRead = FALSE; state = IDLE; buffer[0] = 0; free(receiveBuffer); } } else { state = IDLE; } } break; } // if a packet is in the queue and the process is in idle, attempt to send if (state == IDLE && packetBuffer[currentPacket][0] != 0) { SendMessage(hMain, WM_COMMAND, ASN_ENQ, NULL); } } return 1; }
/* 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; }