У меня есть код для микроконтроллера который работает, но из-за неблокирующего режима…
- User
У меня есть код для микроконтроллера который работает, но из-за неблокирующего режима отвечает сразу на все запросы и иногда ответ на 3 приходит раньше чем на 2й. Я хочу чтоб ответы приходили друг за другом
void SockRead() { int r; struct http_request con_d; struct http_request *req = &con_d; // Проверка наличия входящих соединений long start_time=OS_GetUsSysTick(); struct timeval timeout; timeout.tv_sec = 0.3; timeout.tv_usec = 0; fd_set read_fds; FD_ZERO(&read_fds); FD_SET(server_socket, &read_fds);int select_result = select(server_socket + 1, &read_fds, NULL, NULL, &timeout); if (select_result < 0) { printf("Select error"); return; }
if (FD_ISSET(server_socket, &read_fds)) { // Принятие входящего соединения client_address_length = sizeof(client_address); client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_address_length); if (client_socket < 0) { perror("E1 Err"); return; }
// Установка неблокирующего режима для сокета клиента int flags = fcntl(client_socket, F_GETFL, 0); fcntl(client_socket, F_SETFL, flags | O_NONBLOCK); while (1) { char buffer[256]; //int length_buffer = 0; memset(buffer, 0, sizeof(buffer)); r = recv(client_socket, buffer, sizeof(buffer) - 1, 0); if (r < 0) { break; } else { //length_buffer = r; // Обработка данных parseRequest(buffer, r); } }}
- Assistant
Вам нужно изменить логику работы функции SockRead() так, чтобы она обрабатывала запросы в порядке их поступления, а не просто принимала их и передавала на обработку. Для этого можно создать очередь запросов и помещать в нее каждый новый запрос, а затем последовательно обрабатывать запросы из очереди.
Примерный код:
void SockRead() { int r; struct http_request con_d; struct http_request *req = &con_d;
// Очередь запросов std::queuestd::string request_queue;
// Проверка наличия входящих соединений long start_time=OS_GetUsSysTick(); struct timeval timeout; timeout.tv_sec = 0.3; timeout.tv_usec = 0; fd_set read_fds; FD_ZERO(&read_fds); FD_SET(server_socket, &read_fds);
int select_result = select(server_socket + 1, &read_fds, NULL, NULL, &timeout); if (select_result < 0) { printf("Select error"); return; }
if (FD_ISSET(server_socket, &read_fds)) { // Принятие входящего соединения client_address_length = sizeof(client_address); client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_address_length); if (client_socket < 0) { perror("E1 Err"); return; }
// Установка неблокирующего режима для сокета клиента int flags = fcntl(client_socket, F_GETFL, 0); fcntl(client_socket, F_SETFL, flags | O_NONBLOCK); while (1) { char buffer[256]; memset(buffer, 0, sizeof(buffer)); r = recv(client_socket, buffer, sizeof(buffer) - 1, 0); if (r < 0) { break; } else { // Добавление запроса в очередь request_queue.push(std::string(buffer)); } }}
// Обработка запросов из очереди while (!request_queue.empty()) { parseRequest(request_queue.front().c_str(), request_queue.front().size()); request_queue.pop(); } }
- User
У меня компилятор C99. Язык C. Строка std::queuestd::string request_queue; не компилируется
- Assistant
Вам нужно использовать стандартные структуры данных из библиотеки языка C, например, связанный список или массив динамического размера (динамический буфер).
Пример кода с использованием динамического буфера:
void SockRead() { int r; struct http_request con_d; struct http_request *req = &con_d;
// Динамический буфер для хранения запросов char** request_buffer = NULL; int request_count = 0;
// Проверка наличия входящих соединений long start_time=OS_GetUsSysTick(); struct timeval timeout; timeout.tv_sec = 0.3; timeout.tv_usec = 0; fd_set read_fds; FD_ZERO(&read_fds); FD_SET(server_socket, &read_fds);
int select_result = select(server_socket + 1, &read_fds, NULL, NULL, &timeout); if (select_result < 0) { printf("Select error"); return; }
if (FD_ISSET(server_socket, &read_fds)) { // Принятие входящего соединения client_address_length = sizeof(client_address); client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_address_length); if (client_socket < 0) { perror("E1 Err"); return; }
// Установка неблокирующего режима для сокета клиента int flags = fcntl(client_socket, F_GETFL, 0); fcntl(client_socket, F_SETFL, flags | O_NONBLOCK); while (1) { char buffer[256]; memset(buffer, 0, sizeof(buffer)); r = recv(client_socket, buffer, sizeof(buffer) - 1, 0); if (r < 0) { break; } else { // Увеличение размера буфера на 1 элемент request_count++; request_buffer = realloc(request_buffer, request_count * sizeof(char*)); // Выделение памяти для нового элемента буфера request_buffer[request_count-1] = malloc(r+1); // добавляем 1 для символа конца строки \0 // Копирование данных в новый элемент буфера strcpy(request_buffer[request_count-1], buffer); } }}
// Обработка запросов из буфера for (int i = 0; i < request_count; i++) { parseRequest(request_buffer[i], strlen(request_buffer[i])); // Освобождение памяти, выделенной для элемента буфера free(request_buffer[i]); } // Освобождение памяти, выделенной для буфера free(request_buffer); }
- User
У меня есть код для микроконтроллера который работает, но из-за неблокирующего режима отвечает сразу на все запросы и иногда ответ на 3 приходит раньше чем на 2й. Давай переделаем код так чтоб сокет блокировался, ждал 1 секунду и разблокировался сам по истечению этого времени
void SockRead() { int r; struct http_request con_d; struct http_request *req = &con_d; // Проверка наличия входящих соединений long start_time=OS_GetUsSysTick(); struct timeval timeout; timeout.tv_sec = 0.3; timeout.tv_usec = 0; fd_set read_fds; FD_ZERO(&read_fds); FD_SET(server_socket, &read_fds);
int select_result = select(server_socket + 1, &read_fds, NULL, NULL, &timeout); if (select_result < 0) { printf(“Select error”); return; }
if (FD_ISSET(server_socket, &read_fds)) { // Принятие входящего соединения client_address_length = sizeof(client_address); client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_address_length); if (client_socket < 0) { perror(“E1 Err”); return; }
// Установка неблокирующего режима для сокета клиента int flags = fcntl(client_socket, F_GETFL, 0); fcntl(client_socket, F_SETFL, flags | O_NONBLOCK);
while (1) { char buffer[256]; //int length_buffer = 0; memset(buffer, 0, sizeof(buffer)); r = recv(client_socket, buffer, sizeof(buffer) - 1, 0); if (r < 0) { break; } else { //length_buffer = r; // Обработка данных parseRequest(buffer, r); } } }
- Assistant
Для того чтобы сокет блокировался на определенное время, можно задать таймер на чтение в функции select() перед её вызовом. Таймер будет блокировать сокет на заданное время, а затем функция select() вернет управление, даже если данные на сокете не появились.
Примерный код:
void SockRead() { int r; struct http_request con_d; struct http_request *req = &con_d;
// Проверка наличия входящих соединений long start_time=OS_GetUsSysTick(); fd_set read_fds; FD_ZERO(&read_fds); FD_SET(server_socket, &read_fds);
struct timeval timeout; timeout.tv_sec = 1; // задаем время ожидания в секундах timeout.tv_usec = 0;
int select_result = select(server_socket + 1, &read_fds, NULL, NULL, &timeout); if (select_result < 0) { printf("Select error"); return; } else if (select_result == 0) { // таймаут истек, данные не появились на сокете return; }
if (FD_ISSET(server_socket, &read_fds)) { // Принятие входящего соединения client_address_length = sizeof(client_address); client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_address_length); if (client_socket < 0) { perror("E1 Err"); return; }
// Установка неблокирующего режима для сокета клиента int flags = fcntl(client_socket, F_GETFL, 0); fcntl(client_socket, F_SETFL, flags | O_NONBLOCK); while (1) { char buffer[256]; memset(buffer, 0, sizeof(buffer)); r = recv(client_socket, buffer, sizeof(buffer) - 1, 0); if (r < 0) { break; } else { // Обработка данных parseRequest(buffer, r); } }} }
- User
Поясни мне код int flags = fcntl(client_socket, F_GETFL, 0); fcntl(client_socket, F_SETFL, flags | O_NONBLOCK);
- Assistant
Данный код использует системный вызов fcntl() для установки флага O_NONBLOCK на дескрипторе клиентского сокета.
Системный вызов fcntl() используется для манипуляций с файловыми дескрипторами (в том числе для сокетов) и позволяет установить различные параметры работы файлового дескриптора, в том числе манипуляции с флагами (mode flags) описывающими режим работы файлового дескриптора.
Константа O_NONBLOCK передается в качестве аргумента в вызове fcntl() для того, чтобы установить флаг неблокирующего режима для данного дескриптора. В неблокирующем режиме при чтении/записи на сокет программа не блокируется, если нет готовых для чтения/записи данных на сокете, а сразу возвращает управление.
Таким образом, данный код устанавливает неблокирующий режим для клиентского сокета, чтобы программа могла обрабатывать несколько соединений одновременно.
- User
Какие еще константы кроме O_NONBLOCK есть
- Assistant
Вот некоторые константы, которые могут быть использованы в комбинации с флагами, передаваемыми в системный вызов fcntl():
- O_RDONLY: открыть файл только для чтения.
- O_WRONLY: открыть файл только для записи.
- O_RDWR: открыть файл для чтения и записи.
- O_CREAT: создать файл, если он не существует.
- O_TRUNC: обрезать файл до нулевой длины при открытии.
- O_APPEND: записывать данные в конец файла при каждой записи.
- O_EXCL: если используется вместе с O_CREAT, то будет возвращена ошибка, если файл уже существует.
- O_CLOEXEC: установка флага close-on-exec, что означает, что данный дескриптор будет закрыт, если процесс создает новый процесс с помощью системного вызова fork().
Некоторые дополнительные константы могут быть определены в зависимости от используемой операционной системы. Например, на Unix/Linux системах могут быть определены дополнительные флаги, связанные с информацией о файловой системе, блокировками файлов и т.д.
Подробности о флагах, поддерживаемых в вашей операционной системе, можно найти в документации по системным вызовам и функциям файловой системы.