432 lines
10 KiB
C
432 lines
10 KiB
C
/**
|
|
* @file tcp_client.c
|
|
* @brief TCP Client module implementation for transparent transmission with UART3
|
|
*/
|
|
|
|
#include "tcp_client.h"
|
|
#include "config.h"
|
|
#include "lwip/opt.h"
|
|
#include "lwip/tcp.h"
|
|
#include "lwip/sys.h"
|
|
#include "lwip/sockets.h"
|
|
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#include "stream_buffer.h"
|
|
|
|
#include <string.h>
|
|
|
|
/*---------------------------------------------------------------------------
|
|
* Private Variables
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
/* Client configuration */
|
|
static tcp_client_config_t client_config = {
|
|
.server_ip = {192, 168, 1, 100},
|
|
.server_port = TCP_CLIENT_DEFAULT_PORT,
|
|
.auto_reconnect = true,
|
|
.reconnect_interval_ms = TCP_CLIENT_RECONNECT_DELAY_MS
|
|
};
|
|
|
|
/* Client status */
|
|
static tcp_client_status_t client_status = {
|
|
.state = TCP_CLIENT_STATE_IDLE,
|
|
.rx_bytes = 0,
|
|
.tx_bytes = 0,
|
|
.reconnect_count = 0,
|
|
.errors = 0
|
|
};
|
|
|
|
/* Socket descriptor */
|
|
static int client_socket = -1;
|
|
|
|
/* Stream buffers for UART integration */
|
|
static StreamBufferHandle_t rx_stream = NULL; /* TCP RX -> UART TX */
|
|
static StreamBufferHandle_t tx_stream = NULL; /* UART RX -> TCP TX */
|
|
|
|
/*---------------------------------------------------------------------------
|
|
* Private Functions
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
static int tcp_client_send_all(int sock, const uint8_t *data, uint16_t len)
|
|
{
|
|
uint16_t total = 0;
|
|
|
|
while (total < len)
|
|
{
|
|
int sent = send(sock, data + total, len - total, 0);
|
|
if (sent > 0)
|
|
{
|
|
total += (uint16_t)sent;
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return (int)total;
|
|
}
|
|
|
|
/**
|
|
* @brief Internal connect function
|
|
*/
|
|
static int tcp_client_do_connect(void)
|
|
{
|
|
struct sockaddr_in server_addr;
|
|
int ret;
|
|
|
|
if (client_socket >= 0)
|
|
{
|
|
/* Already connected */
|
|
return 0;
|
|
}
|
|
|
|
client_status.state = TCP_CLIENT_STATE_CONNECTING;
|
|
|
|
/* Create socket */
|
|
client_socket = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (client_socket < 0)
|
|
{
|
|
client_status.state = TCP_CLIENT_STATE_ERROR;
|
|
client_status.errors++;
|
|
return -1;
|
|
}
|
|
|
|
/* Prepare server address */
|
|
memset(&server_addr, 0, sizeof(server_addr));
|
|
server_addr.sin_family = AF_INET;
|
|
server_addr.sin_port = htons(client_config.server_port);
|
|
server_addr.sin_addr.s_addr = ((uint32_t)client_config.server_ip[0]) |
|
|
((uint32_t)client_config.server_ip[1] << 8) |
|
|
((uint32_t)client_config.server_ip[2] << 16) |
|
|
((uint32_t)client_config.server_ip[3] << 24);
|
|
|
|
/* Connect to server */
|
|
ret = connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr));
|
|
if (ret < 0)
|
|
{
|
|
close(client_socket);
|
|
client_socket = -1;
|
|
client_status.state = TCP_CLIENT_STATE_DISCONNECTED;
|
|
client_status.errors++;
|
|
return -1;
|
|
}
|
|
|
|
client_status.state = TCP_CLIENT_STATE_CONNECTED;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
* Public Functions
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Initialize TCP Client module
|
|
*/
|
|
int tcp_client_init(const tcp_client_config_t *config)
|
|
{
|
|
if (config != NULL)
|
|
{
|
|
memcpy(&client_config, config, sizeof(tcp_client_config_t));
|
|
}
|
|
|
|
/* Create stream buffers */
|
|
if (rx_stream == NULL)
|
|
{
|
|
rx_stream = xStreamBufferCreate(TCP_CLIENT_RX_BUFFER_SIZE, 1);
|
|
if (rx_stream == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (tx_stream == NULL)
|
|
{
|
|
tx_stream = xStreamBufferCreate(TCP_CLIENT_TX_BUFFER_SIZE, 1);
|
|
if (tx_stream == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
client_status.state = TCP_CLIENT_STATE_IDLE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Connect to remote server
|
|
*/
|
|
int tcp_client_connect(void)
|
|
{
|
|
return tcp_client_do_connect();
|
|
}
|
|
|
|
/**
|
|
* @brief Disconnect from server
|
|
*/
|
|
int tcp_client_disconnect(void)
|
|
{
|
|
if (client_socket >= 0)
|
|
{
|
|
close(client_socket);
|
|
client_socket = -1;
|
|
}
|
|
|
|
client_status.state = TCP_CLIENT_STATE_DISCONNECTED;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Send data to server
|
|
*/
|
|
int tcp_client_send(const uint8_t *data, uint16_t len)
|
|
{
|
|
int sent;
|
|
|
|
if (client_socket < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
sent = tcp_client_send_all(client_socket, data, len);
|
|
if (sent > 0)
|
|
{
|
|
client_status.tx_bytes += sent;
|
|
}
|
|
else if (sent < 0)
|
|
{
|
|
/* Connection error */
|
|
close(client_socket);
|
|
client_socket = -1;
|
|
client_status.state = TCP_CLIENT_STATE_DISCONNECTED;
|
|
client_status.errors++;
|
|
}
|
|
|
|
return sent;
|
|
}
|
|
|
|
/**
|
|
* @brief Receive data from server
|
|
*/
|
|
int tcp_client_recv(uint8_t *data, uint16_t max_len, uint32_t timeout_ms)
|
|
{
|
|
int received;
|
|
struct timeval tv;
|
|
|
|
if (client_socket < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
/* Set receive timeout */
|
|
tv.tv_sec = timeout_ms / 1000;
|
|
tv.tv_usec = (timeout_ms % 1000) * 1000;
|
|
setsockopt(client_socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
|
|
|
|
received = recv(client_socket, data, max_len, 0);
|
|
if (received > 0)
|
|
{
|
|
client_status.rx_bytes += received;
|
|
}
|
|
else if (received == 0)
|
|
{
|
|
/* Connection closed by server */
|
|
close(client_socket);
|
|
client_socket = -1;
|
|
client_status.state = TCP_CLIENT_STATE_DISCONNECTED;
|
|
}
|
|
|
|
return received;
|
|
}
|
|
|
|
/**
|
|
* @brief Check if connected to server
|
|
*/
|
|
bool tcp_client_is_connected(void)
|
|
{
|
|
return (client_socket >= 0);
|
|
}
|
|
|
|
/**
|
|
* @brief Update server configuration
|
|
*/
|
|
int tcp_client_set_server(const uint8_t *ip, uint16_t port)
|
|
{
|
|
if (ip == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
/* Disconnect if connected */
|
|
if (client_socket >= 0)
|
|
{
|
|
tcp_client_disconnect();
|
|
}
|
|
|
|
memcpy(client_config.server_ip, ip, 4);
|
|
client_config.server_port = port;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Get TCP Client status
|
|
*/
|
|
void tcp_client_get_status(tcp_client_status_t *status)
|
|
{
|
|
if (status != NULL)
|
|
{
|
|
memcpy(status, &client_status, sizeof(tcp_client_status_t));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Get RX StreamBuffer handle
|
|
*/
|
|
void *tcp_client_get_rx_stream(void)
|
|
{
|
|
return rx_stream;
|
|
}
|
|
|
|
/**
|
|
* @brief Get TX StreamBuffer handle
|
|
*/
|
|
void *tcp_client_get_tx_stream(void)
|
|
{
|
|
return tx_stream;
|
|
}
|
|
|
|
/**
|
|
* @brief TCP Client task
|
|
*/
|
|
void tcp_client_task(void *argument)
|
|
{
|
|
const device_config_t *cfg;
|
|
tcp_client_config_t task_cfg;
|
|
uint8_t rx_buffer[256];
|
|
uint8_t tx_buffer[256];
|
|
int received;
|
|
size_t tx_len;
|
|
fd_set read_fds;
|
|
struct timeval tv;
|
|
uint32_t reconnect_timer = 0;
|
|
|
|
(void)argument;
|
|
|
|
/* Initialize client */
|
|
task_cfg.server_ip[0] = 192;
|
|
task_cfg.server_ip[1] = 168;
|
|
task_cfg.server_ip[2] = 1;
|
|
task_cfg.server_ip[3] = 100;
|
|
task_cfg.server_port = TCP_CLIENT_DEFAULT_PORT;
|
|
task_cfg.auto_reconnect = true;
|
|
task_cfg.reconnect_interval_ms = TCP_CLIENT_RECONNECT_DELAY_MS;
|
|
|
|
cfg = config_get();
|
|
if (cfg != NULL)
|
|
{
|
|
memcpy(task_cfg.server_ip, cfg->remote_ip, sizeof(task_cfg.server_ip));
|
|
if (cfg->remote_port > 0)
|
|
{
|
|
task_cfg.server_port = cfg->remote_port;
|
|
}
|
|
if (cfg->reconnect_interval > 0)
|
|
{
|
|
task_cfg.reconnect_interval_ms = cfg->reconnect_interval;
|
|
}
|
|
}
|
|
|
|
tcp_client_init(&task_cfg);
|
|
|
|
while (1)
|
|
{
|
|
/* Handle connection state */
|
|
if (client_socket < 0)
|
|
{
|
|
/* Not connected - try to reconnect */
|
|
if (client_config.auto_reconnect)
|
|
{
|
|
if (xTaskGetTickCount() - reconnect_timer >= pdMS_TO_TICKS(client_config.reconnect_interval_ms))
|
|
{
|
|
if (tcp_client_do_connect() == 0)
|
|
{
|
|
/* Connected successfully */
|
|
client_status.reconnect_count++;
|
|
}
|
|
reconnect_timer = xTaskGetTickCount();
|
|
}
|
|
}
|
|
|
|
/* Wait before retry */
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
continue;
|
|
}
|
|
|
|
/* Handle data transfer if connected */
|
|
|
|
/* Check for data from TCP server */
|
|
FD_ZERO(&read_fds);
|
|
FD_SET(client_socket, &read_fds);
|
|
tv.tv_sec = 0;
|
|
tv.tv_usec = 10000; /* 10ms timeout */
|
|
|
|
if (select(client_socket + 1, &read_fds, NULL, NULL, &tv) > 0)
|
|
{
|
|
if (FD_ISSET(client_socket, &read_fds))
|
|
{
|
|
received = recv(client_socket, rx_buffer, sizeof(rx_buffer), 0);
|
|
if (received > 0)
|
|
{
|
|
/* Forward to UART via stream buffer */
|
|
xStreamBufferSend(rx_stream, rx_buffer, received, pdMS_TO_TICKS(10));
|
|
client_status.rx_bytes += received;
|
|
}
|
|
else if (received == 0)
|
|
{
|
|
/* Connection closed */
|
|
close(client_socket);
|
|
client_socket = -1;
|
|
client_status.state = TCP_CLIENT_STATE_DISCONNECTED;
|
|
reconnect_timer = xTaskGetTickCount();
|
|
}
|
|
else
|
|
{
|
|
/* Error */
|
|
close(client_socket);
|
|
client_socket = -1;
|
|
client_status.state = TCP_CLIENT_STATE_DISCONNECTED;
|
|
client_status.errors++;
|
|
reconnect_timer = xTaskGetTickCount();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Check for data from UART to send to TCP */
|
|
tx_len = xStreamBufferReceive(tx_stream, tx_buffer, sizeof(tx_buffer), 0);
|
|
if (tx_len > 0)
|
|
{
|
|
int sent = tcp_client_send_all(client_socket, tx_buffer, (uint16_t)tx_len);
|
|
if (sent > 0)
|
|
{
|
|
client_status.tx_bytes += sent;
|
|
}
|
|
else if (sent < 0)
|
|
{
|
|
/* Send error */
|
|
close(client_socket);
|
|
client_socket = -1;
|
|
client_status.state = TCP_CLIENT_STATE_DISCONNECTED;
|
|
client_status.errors++;
|
|
reconnect_timer = xTaskGetTickCount();
|
|
}
|
|
}
|
|
|
|
/* Small delay to prevent tight loop */
|
|
vTaskDelay(pdMS_TO_TICKS(1));
|
|
}
|
|
}
|