Продолжаем работу с интерфейсом SOCKET библиотеки стека протоколов LWIP и переходим к следующему транспортному протоколу TCP (Transmission Control Protocol, протокол управления передачей). С данным протоколом мы уже встречались неоднократно. Поэтому, хоть он и является непростым, мы его изучили очень неплохо. Мы знаем, как именно происходит создание и разрыв соединения, знаем, как передаются пакеты TCP, как они делятся на сегменты. Поэтому работать нам с ним и анализировать определённые создающиеся нестандартные ситуации мы уже можем спокойно. Изучая стек протоколов LWIP, мы также сталкивались с протоколом TCP, даже соединяли с помощью него два контроллера, организовывали между ними передачу данных. Правда, всё это происходило с использованием интерфейсов RAW и NETCONN. Второй тип интерфейса уже использовался с участием операционной системы реального времени FREERTOS. Теперь нам уже предстоит поработать с протоколом TCP с использованием интерфейса SOCKET, в котором, как мы уже убедились на протоколе UDP имеется ряд тонкостей, которые помогают нам упростить и практически полностью автоматизировать обмен данными между устройствами.
Со всеми тонкостями программирования протокола TCP мы будем знакомиться в процессе написания кода.
В качестве платы для испытания мы возьмём STM32F746-Discovery, а проект для прототипа мы возьмём из урока 131 с именем LAN8742_UDP_SERVER_SOCKET. Присвоим ему теперь соответствующее имя LAN8742_TCP_SERVER_SOCKET и откроем его в Cube MX.
Добавим в настройках LWIP в разделе Key Options размер кучи до максимального, так как мы уже можем спокойно работать с увеличенным размером кучи
Сгенерируем проект для System Workbench, откроем его там, уберём отладочные настройки при их наличии, а также изменим уровень оптимизации на 1.
Откроем файл main.c и первым делом поправим шапку проекта в main()
TFT_DisplayString(0, 10, (uint8_t *)"TCP Server", CENTER_MODE);
Попробуем собрать проект. Если всё нормально, движемся дальше.
Так как протокол TCP ориентирован на соединение, то целесообразно в одной задаче создать соединение, а обмен с клиентом (или с несколькими клиентами) осуществлять в другой.
Сначала переименуем функцию udp_thread в tcp_thread, удалим из её тела полностью весь код, чтобы не запутаться впоследствии, а также в функции задачи по умолчанию StartDefaultTask изменим имя в создании задачи. Также для задачи увеличим вдвое размер стека
sys_thread_new("tcp_thread", tcp_thread, (void*)&sock01, DEFAULT_THREAD_STACKSIZE * 2, osPriorityNormal);
Над функцией tcp_thread создадим ещё одну функцию для обмена пакетами с клиентом (или клиентами)
|
1 2 3 4 5 |
//--------------------------------------------------------------- static void client_socket_thread(void *arg) { } //--------------------------------------------------------------- |
В функции tcp_thread добавим ряд локальных переменных и указателей
|
1 2 3 4 5 6 7 |
static void tcp_thread(void *arg) { struct_sock *arg_sock; int sock, accept_sock; struct sockaddr_in address, remotehost; socklen_t sockaddrsize; arg_sock = (struct_sock*) arg; |
Создадим сокет
|
1 2 3 4 |
arg_sock = (struct_sock*) arg; if ((sock = socket(AF_INET,SOCK_STREAM, 0)) >= 0) { } |
Мы видим, что во втором аргументе у нас появился параметр SOCK_STREAM, который говорит библиотеке, чтобы сокет создался именно для потоковой передачи. В третьем аргументе поставим ноль, что заставит функцию подобрать параметр по умолчанию, а это и будет протокол TCP.
Если сокет нормально создался, то проинициализируем поля структуры нашего интерфейса (интерфейса сервера)
|
1 2 3 4 5 |
if ((sock = socket(AF_INET,SOCK_STREAM, 0)) >= 0) { address.sin_family = AF_INET; address.sin_port = htons(arg_sock->port); address.sin_addr.s_addr = INADDR_ANY; |
Здесь по сравнению с протоколом UDP ничего не изменилось.
Свяжем сокет со структурой интерфейса и проверим то, что всё прошло нормально. В противном случае сокет закроем
|
1 2 3 4 5 6 7 8 9 |
address.sin_addr.s_addr = INADDR_ANY; if (bind(sock, (struct sockaddr *)&address, sizeof (address)) == 0) { } else { close(sock); return; } |
А в случае положительно результата начнём слушать сокет, применив для этого функцию listen, первым аргументом которой будет дескриптор сокета, а вторым — максимальное количество попыток соединений в очереди
|
1 2 3 |
if (bind(sock, (struct sockaddr *)&address, sizeof (address)) == 0) { listen(sock, 5); |
Добавим бесконечный цикл, в котором ответим на попытку соединения с клиентом, если таковая будет иметь место
|
1 2 3 4 5 |
listen(sock, 5); for(;;) { accept_sock = accept(sock, (struct sockaddr *)&remotehost, (socklen_t *)&sockaddrsize); } |
Данная функция создаёт ещё один сокет — сокет для клиента. Соединений может быть не одно, поэтому и дескрипторы будут под разными номерами. Выведем номер дескриптора через шину USART в терминальную программу на ПК
|
1 2 3 |
accept_sock = accept(sock, (struct sockaddr *)&remotehost, (socklen_t *)&sockaddrsize); sprintf(str_usart," socket: %d\r\n", accept_sock); HAL_UART_Transmit(&huart1,(uint8_t*)str_usart,strlen(str_usart),0x1000); |
Создадим глобальную структуру для параметра передачи в задачу обмена пакетами с клиентом и создадим переменную типа данной структуры
|
1 2 3 4 5 6 7 8 |
struct_conn conn01; typedef struct struct_client_socket_t { struct sockaddr_in remotehost; socklen_t sockaddrsize; int accept_sock; uint16_t y_pos; } struct_client_socket; struct_client_socket client_socket01; |
Я думаю, смысл полей структуры понятен. А если не понятен, то сейчас мы всё увидим.
Вернёмся в функцию tcp_thread и в случае положительного результата создания сокета для соединения с клиентом заполним поля данной структуры и затем создадим задачу для обмена пакетами с клиентом
|
1 2 3 4 5 6 7 8 9 |
HAL_UART_Transmit(&huart1,(uint8_t*)str_usart,strlen(str_usart),0x1000); if(accept_sock >= 0) { client_socket01.accept_sock = accept_sock; client_socket01.remotehost = remotehost; client_socket01.sockaddrsize = sockaddrsize; client_socket01.y_pos = arg_sock->y_pos; sys_thread_new("client_socket_thread", client_socket_thread, (void*)&client_socket01, DEFAULT_THREAD_STACKSIZE, osPriorityNormal ); } |
В функции client_socket_thread добавим несколько структур и переменных, также объявим размер буфера для приёма и передачи пакетов, а также заберём наши параметры в соответствующую переменную структуры
|
1 2 3 4 5 6 7 8 |
static void client_socket_thread(void *arg) { int buflen = 150; int ret, accept_sock; struct sockaddr_in remotehost; socklen_t sockaddrsize; struct_client_socket *arg_client_socket; arg_client_socket = (struct_client_socket*) arg; |
Присвоим параметры, пришедшие из другой задачи, соответствующим переменным
|
1 2 3 4 |
arg_client_socket = (struct_client_socket*) arg; remotehost = arg_client_socket->remotehost; sockaddrsize = arg_client_socket->sockaddrsize; accept_sock = arg_client_socket->accept_sock; |
Добавим бесконечный цикл, в котором попытаемся принять пакет от клиента
|
1 2 3 4 5 |
accept_sock = arg_client_socket->accept_sock; for(;;) { ret = recvfrom( accept_sock,out_buffer, buflen, 0, (struct sockaddr *)&remotehost, &sockaddrsize); } |
Приём пакета происходит аналогично тому, как и в случае с UDP.
В качестве буфера используем одну из областей памяти, объявленных в предыдущих занятиях в области памяти SDRAM.
Если пакет пришел, то добавим ноль к пакету, чтобы использовать его как строку для отображения на дисплее
|
1 2 3 4 5 |
ret = recvfrom( accept_sock,out_buffer, buflen, 0, (struct sockaddr *)&remotehost, &sockaddrsize); if(ret > 0) { out_buffer[ret] = 0; } |
Чтобы нам закрыть соединение, мы будем с клиента посылать команду, например «-c«, поэтому давайте напишем обнаружение подобной строки, в теле которого закроем сокет и уничтожим задачу
|
1 2 3 4 5 6 |
out_buffer[ret] = 0; if(strcmp((char*)out_buffer, "-c") == 0) { close(accept_sock); osThreadTerminate(NULL); } |
В качестве клиента мы будем использовать программу Putty, которая любит перевод каретки и возврат строки оформлять в отдельный пакет. Поэтому давайте отфильтруем такие пакеты и не будем на них никак реагировать. А в случае нормального пакета мы, наоборот, добавим к пакету возврат каретки и перевод строки
|
1 2 3 4 5 6 |
osThreadTerminate(NULL); } if(strcmp((char*)out_buffer, "\r\n") != 0) { strcat((char*)out_buffer,"\r\n"); } |
Для начала отобразим пришедшую строку в терминальной программе
|
1 2 |
strcat((char*)out_buffer,"\r\n"); HAL_UART_Transmit(&huart1,out_buffer,strlen((char*)out_buffer),0x1000); |
Также отобразим в терминальной программе количество байтов в пакете
|
1 2 3 |
HAL_UART_Transmit(&huart1,out_buffer,strlen((char*)out_buffer),0x1000); sprintf(str_usart,"%d\r\n", ret); HAL_UART_Transmit(&huart1,(uint8_t *)str_usart,strlen(str_usart),0x1000); |
Уберём возврат строки и перевод каретки, вставив вместо них ноль
|
1 2 |
HAL_UART_Transmit(&huart1,(uint8_t *)str_usart,strlen(str_usart),0x1000); out_buffer[ret] = 0; |
Отобразим порт и строку из пакета на дисплее
|
1 2 3 |
out_buffer[ret] = 0; sprintf(str_usart,"%5u %-20s", ntohs(remotehost.sin_port), (char*)out_buffer); TFT_DisplayString(0, 40, (uint8_t *)str_usart, LEFT_MODE); |
Отобразим ещё минимальный оставшийся размер кучи
|
1 2 3 |
TFT_DisplayString(0, 40, (uint8_t *)str_usart, LEFT_MODE); sprintf(str_usart,"%7u",xPortGetMinimumEverFreeHeapSize()); TFT_DisplayString(0, 80, (uint8_t *)str_usart, LEFT_MODE); |
И напоследок отправим строку в качестве «эха» клиенту в ответ, добавив к ней возврат каретки и перевод строки
|
1 2 3 |
TFT_DisplayString(0, 80, (uint8_t *)str_usart, LEFT_MODE); strcat((char*)out_buffer,"\r\n"); sendto(accept_sock,out_buffer,strlen((char*)out_buffer),0,(struct sockaddr *)&remotehost, sockaddrsize); |
Соберём код, прошьём контроллер и запустим программу WireShark, отфильтровавшись по нужному IP сервера.
Также запустим терминальную программу, соединившись в ней с нужным портом.
Запустим программу Putty, настроив необходимый порт и адрес. Запустим соединение, нажав кнопку Open
Посмотрим в анализаторе трафика, что мы благополучно соединились с нашим сервером
Также мы видим в терминальной программе, что у нас создался сокет с дескриптором 1
Попробуем что-нибудь передать серверу
Мы видим, что пакет вернулся.
Также мы видим, что обмен нормально идёт в анализаторе
Также мы видим пришедшую строку и её размер в терминальной программе
Данная строка также отображается и на нашем дисплее
Попробуем создать ещё одно соединение, запустив ещё одну сессию программы Putty.
Соединение у нас создалось благополучно
Сокет с дескриптором 2 также создан
Попробуем передать что-нибудь серверу. Все строки доходят до него отлично
Запустим ещё одну сессию Putty, чтобы создать третье соединение.
У нас появился теперь сокет уже под номером 3
Строки также отлично передаются.
А вот если мы попытаемся создать четвёртый сокет, то получим скорее всего ошибку, хотя когда я писал первую версию проекта, мне удавалось создать 4 соединения после увеличения кучи. Возможно, что я что-то забыл
В терминальной программе мы видим также ошибку -1
Ну нам в принципе и трёх соединений хватит. Вы можете поиграть с размерами, возможно у вас получится создать одновременно больше соединений.
Теперь попробуем закрыть одно из трёх соединений, передав известную команду в командной строке Putty. Соединение закроется
Также мы видим обоюдное закрытие соединения в Wireshark
Если мы запустим опять сессию Putty, то у нас создастся сокет снова с номером 3
Давайте закроем все сессии с помощью команды и запустим опять сессию Putty.
У нас снова создастся сокет с дескриптором 1
Это подтверждает то, что мы спокойно можем сколь угодно закрывать соединения и заново их открывать, самое главное, не превышая максимум в одно время.
Итак, в данном занятии мы научились работать с использованием интерфейса SOCKET уже с протоколом TCP, который ориентирован на обязательное создание соединения. Мы создали несложный, но вполне работоспособный сервер.
Всем спасибо за внимание!
Предыдущий урок Программирование МК STM32 Следующий урок
Отладочную плату можно приобрести здесь 32F746G-DISCOVERY
Смотреть ВИДЕОУРОК (нажмите на картинку)
Здравствуйте, создал программу по вашему уроку, все работает, но после 5 установленных и затем разорванных соединений не удается создать новое, выдает ошибку Out of memory error, буду очень благодарен за помощь
если ты еще не разобрался в проблеме, дам наводку. Для каждого соединения создается свой нетбуффер и неткон. Если при разрыве соединения их не удалять, то вполне справедливо, памяти будет не хватать. Пользуйся функцией close(sock);
Сам сейчас стою перед проблемой как в lwip отслеживать состояние socket'a? Использую freertos, TCP-server. У меня постоянно крутится задача в которой постоянно запускаю lwip_accept(s,addr,addrlen). Если соединение произошло, создаю две задачи, одну на прием, другую на передачу с информацией по текущему сокету. Все работает отлично. Прием и передача через очередь. Проблема заключается в отслеживании состоянии сокета, пока не разобрался какой функцией оно происходит. Сейчас кроме как отследить неудачную попытку отправки в сокет, клиенту ничего придумать не могу. Ресурсы запустить еще одну задачу на проверку состояния сокета есть.