void client::run_client_send() { HANDLE Semaphores[2]; Semaphores[0] = Semaphore_client_send; Semaphores[1] = Semaphore_client_send_exit; while (1) { ReleaseSemaphore(Semaphore_server_send, 1, NULL); int index = WaitForMultipleObjects(2, Semaphores, FALSE, INFINITE) - WAIT_OBJECT_0; if (index == 1) break; if (getch_noblock() != -1) { DWORD number_of_bytes_written; print_server(); cin.clear(); getline(cin, message_to_send); ReleaseSemaphore(Semaphore_server_start_print, 1, NULL); int number_of_blocks = message_to_send.size() / size_of_buff + 1; int size = message_to_send.size(); WriteFile(hPipe, &number_of_blocks, sizeof(number_of_blocks), &number_of_bytes_written, (LPOVERLAPPED)NULL); WriteFile(hPipe, &size, sizeof(size), &number_of_bytes_written, (LPOVERLAPPED)NULL); for (int i = 0; i < number_of_blocks; i++) { message_to_send.copy(buff, size_of_buff, i * size_of_buff); if (!WriteFile(hPipe, buff, size_of_buff, &number_of_bytes_written, (LPOVERLAPPED)NULL)) { cout << "Write Error" << endl; } } WaitForSingleObject(Semaphore_server_end_print, INFINITE); } Sleep(1); } }
void server::server_send() { HANDLE Semaphores[2]; Semaphores[0] = Semaphore_server[3]; //Semafore_Server_Send Semaphores[1] = Semaphore_server[4]; //Semafore_Server_Send_exit while (1) { WaitForMultipleObjects(2, Semaphores, FALSE, INFINITE) - WAIT_OBJECT_0; //received permission ReleaseSemaphore(Semaphore_client[3], 1, NULL); //SEMAPHORE_CLIENT_SEND if (getch_noblock() != -1) { DWORD numberber_of_bytes_written; print_client(); cin.clear(); getline(cin, send_message); if (send_message == "end\0" || send_message == "exit\0") { ReleaseSemaphore(Semaphore_server[2], 1, NULL); //SEMAPHORE_SERVER_PRINT_EXIT ReleaseSemaphore(Semaphore_client[2], 1, NULL); //SEMAPHORE_CLIENT_PRINT_EXIT ReleaseSemaphore(Semaphore_client[4], 1, NULL); //SEMAPHORE_CLIENT_SEND_EXIT WaitForSingleObject(ChildProcessInfo.hProcess, INFINITE); break; } ReleaseSemaphore(Semaphore_client[0], 1, NULL); //SEMAPHORE_CLIENT_START_PRINT int numberber_of_blocks = send_message.size() / size_of_buffer + 1; int size = send_message.size(); WriteFile(hNamedPipe, &numberber_of_blocks, sizeof(numberber_of_blocks), &numberber_of_bytes_written, (LPOVERLAPPED)NULL); WriteFile(hNamedPipe, &size, sizeof(size), &numberber_of_bytes_written, (LPOVERLAPPED)NULL); for (int i = 0; i < numberber_of_blocks; i++) { send_message.copy(buffer, size_of_buffer, i * size_of_buffer); if (!WriteFile(hNamedPipe, buffer, size_of_buffer, &numberber_of_bytes_written, (LPOVERLAPPED)NULL)) { cout << "Write Error" << endl; } } WaitForSingleObject(Semaphore_client[1], INFINITE); //SEMAPHORE_CLIENT_END_PRINT } Sleep(1); } }
void client::run_client_send() { void *buffer = shmat(shm_id, NULL, 0); while (1) { system("stty -echo"); ReleaseSemaphore(sem_s_id, 0); WaitSemaphore(sem_c_id, 0); if (getch_noblock() != -1) { ReleaseSemaphore(sem_s_id, 1); message_to_send.clear(); cout << "Server: "; system("stty echo"); tcflush(STDIN_FILENO, TCIFLUSH); getline(cin, message_to_send); system("stty -echo"); ReleaseSemaphore(sems_id, 2); length = message_to_send.size(); *(int*)buffer = length; ReleaseSemaphore(sems_id, 0); WaitSemaphore(sems_id, 1); NumberOfBlocks = ceil((double)length / (double)size_of_buff); for (int i = 0; i < NumberOfBlocks; i++) { message_to_send.copy((char*)buffer, size_of_buff, i*size_of_buff); ReleaseSemaphore(sems_id, 0); WaitSemaphore(sems_id, 1); } WaitSemaphore(sems_id, 3); } usleep(SLEEP_TIME_ONE); length = *(int*)buffer; if (length == -1) break; } }
int main(int argc, char *argv[]) { char key; int threadsCounter = 0; int currentPrinting = 1; MyThread* threads[10]; #ifdef _WIN32 while (1) { key = getch_noblock(); Sleep(1); switch (key) { case '+': if (threadsCounter < 10) { threadsCounter++; threads[threadsCounter - 1] = new MyThread(threadsCounter); } break; case '-': if (threadsCounter > 0) { threads[threadsCounter - 1]->closeThread(); threadsCounter--; } break; case 'q': if (threadsCounter > 0) { for (int i = 0; i < threadsCounter; i++) threads[i]->closeThread(); } return 0; } if (threadsCounter && threads[currentPrinting - 1]->canPrint()) { if (currentPrinting >= threadsCounter) currentPrinting = 1; else currentPrinting++; threads[currentPrinting - 1]->startPrint(); } } #elif __linux__ initscr(); clear(); noecho(); refresh(); nodelay(stdscr, TRUE); while (1) { key = getch(); usleep(1000); fflush(stdout); refresh(); switch (key) { case '+': if (threadsCounter < 10) { threadsCounter++; threads[threadsCounter - 1] = new MyThread(threadsCounter); } break; case '-': if (threadsCounter > 0) { threads[threadsCounter - 1]->closeThread(); threadsCounter--; } break; case 'q': if (threadsCounter > 0) { for (int i = 0; i < threadsCounter; i++) threads[i]->closeThread(); } clear(); endwin(); return 0; } if (threadsCounter && threads[currentPrinting - 1]->canPrint()) { if (currentPrinting >= threadsCounter) currentPrinting = 1; else currentPrinting++; threads[currentPrinting - 1]->startPrint(); } refresh(); } #endif }
void server::server_send(char *argv) { switch (pid) { case -1: printf("New process is not created\n"); return; case 0: execlp("mate-terminal", "mate-terminal", "-x", argv, "-n 2", itoa(shm_id), itoa(sem_id), itoa(sems_id), itoa(sem_server_id), itoa(sem_client_id), NULL); break; default: { void *bufferer = shmat(shm_id, NULL, 0); while (1) { system("stty -echo"); ReleaseSemaphore(sem_client_id, 0); WaitSemaphore(sem_server_id, 0); if (getch_noblock() != -1) { ReleaseSemaphore(sem_client_id, 1); send_message.clear(); cout << "Client: "; system("stty echo"); tcflush(STDIN_FILENO, TCIFLUSH); getline(cin, send_message); system("stty -echo"); ReleaseSemaphore(sem_id, 2); if (send_message == "exit" || send_message == "end") { length = -1; *(int*)bufferer = length; ReleaseSemaphore(sem_id, 0); ReleaseSemaphore(sems_id, 2); ReleaseSemaphore(sems_id, 0); ReleaseSemaphore(sem_client_id, 0); WaitSemaphore(sem_id, 1); waitpid(pid, NULL, 0); break; } length = send_message.size(); *(int*)bufferer = length; ReleaseSemaphore(sem_id, 0); WaitSemaphore(sem_id, 1); numberberOfBlocks = ceil((double)length / (double)size_of_buffer); for (int i = 0; i < numberberOfBlocks; i++) { send_message.copy((char*)bufferer, size_of_buffer, i*size_of_buffer); ReleaseSemaphore(sem_id, 0); WaitSemaphore(sem_id, 1); } WaitSemaphore(sem_id, 3); } usleep(SLEEP_TIME_ONE); } } break; } }
int main(int argc, char *argv[]) { #ifdef __linux__ initscr(); clear(); noecho(); refresh(); nodelay(stdscr, TRUE); #endif char symbol; int threadsCount = 0; int currentThread = 1; Thread* thread[THREADS_NUMBER]; while(TRUE) { symbol = getch_noblock(); Sleep(SHORT_SLEEP); fflush(stdout); #ifdef __linux__ refresh(); #endif switch (symbol) { case '+': if (threadsCount < THREADS_NUMBER) { thread[threadsCount++] = new Thread(threadsCount + 1); } break; case '-': if (threadsCount > 0) { thread[--threadsCount]->closeThread(); } break; case 'q': if (threadsCount > 0) { for (int i = 0; i < threadsCount; i++) { thread[i]->closeThread(); #ifdef __linux__ pthread_join(thread[i]->getInner(), NULL); #endif } } #ifdef __linux__ clear(); endwin(); #elif _WIN32 closeMutex(); #endif return 0; } if (threadsCount && thread[currentThread - 1]->canPrint()) { if (currentThread >= threadsCount) currentThread = 1; else currentThread++; thread[currentThread - 1]->startPrint(); } #ifdef __linux__ refresh(); #endif } }
//========================================================================= // MAIN PROGRAM //========================================================================= int main (int argc, char *argv[]) { Aardvark handle; int port = 0; u08 addr = 0; int timeout_ms = 0; u08 slave_resp[SLAVE_RESP_SIZE]; int i; /* if (argc < 4) { printf("usage: aai2c_slave PORT SLAVE_ADDR TIMEOUT_MS\n"); printf(" SLAVE_ADDR is the slave address for this device\n"); printf("\n"); printf(" The timeout value specifies the time to\n"); printf(" block until the first packet is received.\n"); printf(" If the timeout is -1, the program will\n"); printf(" block indefinitely.\n"); return 1; } */ /* port = atoi(argv[1]); addr = (u08)strtol(argv[2], 0, 0); timeout_ms = atoi(argv[3]); */ port = 0; //atoi(argv[1]); addr = 0x08; //(u08)strtol(argv[5], 0, 0); timeout_ms = 1*1000; //atoi(argv[6]); // Open the device handle = aa_open(port); if (handle <= 0) { printf("Unable to open Aardvark device on port %d\n", port); printf("Error code = %d\n", handle); return 1; } // Ensure that the I2C subsystem is enabled aa_configure(handle, AA_CONFIG_SPI_I2C); // Disable the Aardvark adapter's power pins. // This command is only effective on v2.0 hardware or greater. // The power pins on the v1.02 hardware are not enabled by default. aa_target_power(handle, AA_TARGET_POWER_NONE); // Set the slave response; this won't be used unless the master // reads bytes from the slave. for (i=0; i<SLAVE_RESP_SIZE; ++i) slave_resp[i] = 'A' + i; //No response: aa_i2c_slave_set_response(handle, SLAVE_RESP_SIZE, slave_resp); aa_i2c_slave_set_response(handle, 0, NULL); // Enable the slave aa_i2c_slave_enable(handle, addr, 0, 0); // Watch the I2C port printf("Press 'q' to exit the program!!! \n"); do { dump(handle, timeout_ms); } while(getch_noblock() != 'q' ); // Disable the slave and close the device aa_i2c_slave_disable(handle); aa_close(handle); return 0; }