Many updates, adding code for the various MCP servers

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2025 Ghislaine and David Robert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MCP_servers/W600-embedded-OBD2/.gitignore

@@ -0,0 +1,46 @@
+# Object files
+*.o
+
+# Library archives (build artifacts)
+*.a
+
+# Binary files and firmware images
+*.bin
+*.elf
+*.img
+*.fls
+*.map
+*.gz
+
+# Build output directory
+Bin/wm_w600.*
+Bin/*_w600.*
+
+# Tools build artifacts
+Tools/GNU/*.bin
+Tools/GNU/*.elf
+Tools/GNU/*.map
+Tools/wm_tool
+
+# Editor and IDE files
+*.swp
+*.swo
+*~
+.vscode/
+.idea/
+*.code-workspace
+
+# OS-specific files
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Dependency files
+*.d
+*.dep
+
+# Debug files
+*.dbg
+
+# WiFi credentials (keep out of source control)
+App/wifi_credentials.h

MCP_servers/W600-embedded-OBD2/App/main.c

@@ -0,0 +1,170 @@
+#define LOG_TAG "Main"
+
+#include "wm_include.h"
+#include "wm_http_fwup.h"
+#include "wm_watchdog.h"
+#include "wm_log.h"
+// The file wifi_credentials.h should define WIFI_SSID and WIFI_PASSWORD
+// and is NOT checked into source control
+#include "wifi_credentials.h"
+#include "wm_app_config.h"
+#include "elm327.h"
+#include "mcp_server.h"
+
+// Flag to track when IP is obtained
+static volatile u8 ip_obtained = 0;
+
+// OTA task function
+static void ota_update()
+{
+	int ret;
+	char firmware_url[sizeof(FIRMWARE_SERVER "/" FIRMWARE_FILENAME)];
+	snprintf(firmware_url, sizeof(firmware_url), "%s/%s", FIRMWARE_SERVER, FIRMWARE_FILENAME);
+
+	wm_log_info("Checking for OTA Firmware Update, Firmware URL: %s", firmware_url);
+	ret = t_http_fwup(firmware_url);
+
+	if (ret == 0)
+	{
+		wm_log_info("OTA Update Successful! Rebooting to apply new firmware...");
+		tls_os_time_delay(HZ * 2);  // Wait 2 seconds before reboot
+		tls_sys_reset();  // Reboot to apply the new firmware
+	}
+	else
+	{
+		wm_log_info("OTA Update not available, Error code: %d", ret);
+	}
+}
+
+// Network status callback
+static void con_net_status_changed_event(u8 status)
+{
+    switch(status)
+    {
+    case NETIF_WIFI_JOIN_SUCCESS:
+        wm_log_info("NETIF_WIFI_JOIN_SUCCESS");
+        break;
+    case NETIF_WIFI_JOIN_FAILED:
+        wm_log_error("NETIF_WIFI_JOIN_FAILED");
+        break;
+    case NETIF_WIFI_DISCONNECTED:
+        wm_log_warn("NETIF_WIFI_DISCONNECTED");
+        break;
+    case NETIF_IP_NET_UP:
+    {
+        struct tls_ethif *tmpethif = tls_netif_get_ethif();
+        print_ipaddr(&tmpethif->ip_addr);
+#if TLS_CONFIG_IPV6
+        print_ipaddr(&tmpethif->ip6_addr[0]);
+        print_ipaddr(&tmpethif->ip6_addr[1]);
+        print_ipaddr(&tmpethif->ip6_addr[2]);
+#endif
+        ip_obtained = 1;  // Signal that IP has been obtained
+    }
+    break;
+    default:
+        wm_log_warn("UNKNOWN STATE:%d", status);
+        break;
+    }
+}
+
+// Main entry point: this is where the code of your application starts
+void UserMain(void)
+{
+	int ret;
+	struct tls_param_ip *ip_param = NULL;
+	u8 wireless_protocol = 0;
+
+	// Initialize logging system first
+	wm_log_init();
+
+	wm_log_info("Diagnostic ELM237 MCP Server Firmware Starting...");
+
+	// Disconnect any existing WiFi connection
+	tls_wifi_disconnect();
+
+	// Set wireless protocol to infrastructure (station) mode
+	tls_param_get(TLS_PARAM_ID_WPROTOCOL, (void *)&wireless_protocol, TRUE);
+	if (TLS_PARAM_IEEE80211_INFRA != wireless_protocol)
+	{
+		tls_wifi_softap_destroy();  // Destroy any AP mode
+		wireless_protocol = TLS_PARAM_IEEE80211_INFRA;
+		tls_param_set(TLS_PARAM_ID_WPROTOCOL, (void *)&wireless_protocol, FALSE);
+		wm_log_info("Set to infrastructure (station) mode");
+	}
+
+	// Disable oneshot configuration mode
+	tls_wifi_set_oneshot_flag(0);
+
+	// Enable DHCP
+	ip_param = tls_mem_alloc(sizeof(struct tls_param_ip));
+	if (ip_param)
+	{
+		tls_param_get(TLS_PARAM_ID_IP, ip_param, FALSE);
+		ip_param->dhcp_enable = TRUE;
+		tls_param_set(TLS_PARAM_ID_IP, ip_param, FALSE);
+		tls_mem_free(ip_param);
+		wm_log_info("DHCP enabled");
+	}
+
+	// Register network interface status callback
+	tls_netif_add_status_event(con_net_status_changed_event);
+
+	// Disable WiFi power save mode
+	tls_wifi_set_psflag(0, 0);
+
+	// Connect to WiFi access point
+	wm_log_info("Connecting to WiFi: %s", WIFI_SSID);
+	ret = tls_wifi_connect((u8 *)WIFI_SSID, strlen(WIFI_SSID),
+	                       (u8 *)WIFI_PASSWORD, strlen(WIFI_PASSWORD));
+
+	if (ret == WM_SUCCESS)
+	{
+		wm_log_info("WiFi connection initiated, please wait...");
+	}
+	else
+	{
+		wm_log_error("Failed to start WiFi connection (error %d)", ret);
+		return;  // Exit if WiFi connection failed
+	}
+
+	// Wait for IP address to be obtained via DHCP
+	wm_log_info("Waiting for IP address...");
+	while (!ip_obtained)
+	{
+		tls_os_time_delay(HZ / 10);  // Wait 100ms
+	}
+
+	wm_log_info("IP address obtained");
+
+#if (TLS_CONFIG_UDP_SYSLOG == CFG_ON)
+	if (wm_log_syslog_init() == 0) {
+		wm_log_info("UDP syslog initialized - remote logging active");
+	} else {
+		wm_log_error("Failed to initialize UDP syslog");
+	}
+	tls_os_time_delay(HZ * 2);
+#endif
+
+#if ENABLE_OTA
+	ota_update();
+#endif
+
+	// Initialize ELM327
+	if (elm327_init() != WM_SUCCESS) {
+		wm_log_error("Failed to initialize ELM327");
+		return;
+	}
+
+	// Start MCP server on port 80
+	if (mcp_server_init(80) != WM_SUCCESS) {
+		wm_log_error("Failed to start MCP server");
+	}
+
+	wm_log_info("Setup complete. Entering main loop...");
+
+	while (1) {
+		tls_os_time_delay(HZ * 10);  // Sleep for 10 seconds
+	}
+}
+

MCP_servers/W600-embedded-OBD2/App/wifi_credentials.h.template

@@ -0,0 +1,8 @@
+#ifndef WM_WIFI_CREDENTIALS_H
+#define WM_WIFI_CREDENTIALS_H
+
+// WiFi credentials - Copy this file to wifi_credentials.h and fill in your network details
+#define WIFI_SSID        "your_ssid_here"
+#define WIFI_PASSWORD    "your_password_here"
+
+#endif /* WM_WIFI_CREDENTIALS_H */

MCP_servers/W600-embedded-OBD2/App/wm_app_config.h

@@ -0,0 +1,11 @@
+#ifndef WM_APP_CONFIG_H
+#define WM_APP_CONFIG_H
+
+// OTA firmware update server - modify this to point to your firmware server
+#define FIRMWARE_SERVER  "http://192.168.1.1"
+#define FIRMWARE_FILENAME    "wm_w600_gz.img"
+
+// Set to 1 to enable automatic OTA updates, 0 to disable
+#define ENABLE_OTA       1
+
+#endif /* WM_APP_CONFIG_H */

MCP_servers/W600-embedded-OBD2/Bin/firmware_server.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+import http.server
+import socketserver
+import sys
+
+PORT = 80  # default port
+if len(sys.argv) > 1:
+    PORT = int(sys.argv[1])
+
+Handler = http.server.SimpleHTTPRequestHandler
+
+class SingleRequestTCPServer(socketserver.TCPServer):
+    allow_reuse_address = True
+
+    def handle_request(self):
+        """Handle a single request and then stop."""
+        super().handle_request()
+        print("Request served, exiting.")
+        self.server_close()
+        sys.exit(0)
+
+with SingleRequestTCPServer(("", PORT), Handler) as httpd:
+    print(f"Serving HTTP on port {PORT} (single request)...")
+    httpd.handle_request()

MCP_servers/W600-embedded-OBD2/Include/App/elm327.h

@@ -0,0 +1,91 @@
+/**
+ * @file    elm327.h
+ *
+ * @brief   ELM327 OBD-II Interface Module
+ *
+ * This module provides a simple command-response interface for communicating
+ * with an ELM327 chip over UART1. The ELM327 is connected at 38400 baud 8N1.
+ */
+#ifndef ELM327_H
+#define ELM327_H
+
+#include "wm_type_def.h"
+
+#define ELM327_MAX_RESPONSE_LEN  512
+#define ELM327_DEFAULT_TIMEOUT   2000  // 2 seconds
+
+/**
+ * @brief          Initialize ELM327 communication on UART1
+ *
+ * @retval         WM_SUCCESS    success
+ * @retval         WM_FAILED     failed
+ *
+ * @note           Configures UART1 at 38400 baud, 8N1, no flow control
+ */
+int elm327_init(void);
+
+/**
+ * @brief          Send command to ELM327 and wait for response
+ *
+ * @param[in]      cmd          Command string to send (e.g., "ATZ", "01 0D")
+ * @param[out]     response     Buffer to store response
+ * @param[in]      max_len      Maximum length of response buffer
+ * @param[in]      timeout_ms   Timeout in milliseconds
+ *
+ * @retval         >0           Number of bytes in response (success)
+ * @retval         -1           Not initialized
+ * @retval         -2           Invalid parameters
+ * @retval         -3           UART send failed
+ * @retval         -4           Timeout waiting for response
+ *
+ * @note           The function automatically appends '\r' if not present in cmd
+ * @note           Response includes the '>' prompt at the end
+ */
+int elm327_send_command(const char *cmd, char *response,
+                        int max_len, u32 timeout_ms);
+
+/**
+ * @brief          Cleanup ELM327 resources
+ *
+ * @retval         None
+ *
+ * @note           Unregisters callbacks and deletes semaphore
+ */
+void elm327_deinit(void);
+
+#if (TLS_CONFIG_ELM327_SIMULATION == CFG_ON)
+/**
+ * @brief          Enable or disable simulation mode
+ *
+ * @retval         None
+ *
+ * @note           When simulation is enabled, OBD-II commands return simulated
+ *                 responses. AT commands always go to real hardware.
+ * @note           Only available when compiled with TLS_CONFIG_ELM327_SIMULATION
+ */
+void elm327_set_simulation_mode(bool enable);
+
+/**
+ * @brief          Check if simulation mode is enabled
+ *
+ * @retval         true         Simulation is enabled
+ * @retval         false        Using real hardware
+ *
+ * @note           Only available when compiled with TLS_CONFIG_ELM327_SIMULATION
+ */
+bool elm327_is_simulation_enabled(void);
+
+/**
+ * @brief          Set simulated engine state (running/stopped)
+ *
+ * @param[in]      running      true = engine on, false = engine off
+ *
+ * @retval         None
+ *
+ * @note           Affects simulated RPM, temperature, and other dynamic values
+ * @note           Only available when compiled with TLS_CONFIG_ELM327_SIMULATION
+ */
+void elm327_set_engine_state(bool running);
+#endif
+
+#endif // ELM327_H

MCP_servers/W600-embedded-OBD2/Include/App/elm327_history.h

@@ -0,0 +1,66 @@
+/**
+ * @file    elm327_history.h
+ *
+ * @brief   ELM327 OBD-II Data History Module
+ *
+ * This module periodically collects OBD-II PID values (RPM, Speed, Coolant Temp)
+ * and stores them in a ring buffer for historical analysis via MCP streaming.
+ */
+#ifndef ELM327_HISTORY_H
+#define ELM327_HISTORY_H
+
+#include "wm_type_def.h"
+
+// Configuration
+#define ELM327_HISTORY_SIZE         200     // Ring buffer capacity
+#define ELM327_HISTORY_INTERVAL_MS  10000   // 10 seconds between samples
+
+/**
+ * Single history entry containing OBD-II PID values
+ */
+typedef struct {
+    u32 timestamp;      // System time when sampled (in ticks)
+    u16 rpm;            // Engine RPM (0-16383)
+    u8  speed;          // Vehicle speed in km/h (0-255)
+    s8  coolant_temp;   // Coolant temperature in Celsius (-40 to +215)
+    u8  valid;          // 1 if entry is valid, 0 if empty
+} elm327_history_entry_t;
+
+/**
+ * @brief          Initialize ELM327 history module
+ *
+ * Creates periodic task that samples OBD-II PIDs every 10 seconds.
+ *
+ * @retval         WM_SUCCESS    success
+ * @retval         WM_FAILED     failed
+ *
+ * @note           Requires elm327_init() to be called first
+ */
+int elm327_history_init(void);
+
+/**
+ * @brief          Get total number of entries in history
+ *
+ * @retval         Number of valid entries (0 to ELM327_HISTORY_SIZE)
+ */
+int elm327_history_get_count(void);
+
+/**
+ * @brief          Get a specific history entry by index
+ *
+ * @param[in]      index        Entry index (0 = oldest, count-1 = newest)
+ *
+ * @retval         Pointer to entry, or NULL if index out of range
+ *
+ * @note           Returned pointer is valid until next sample is taken
+ */
+const elm327_history_entry_t* elm327_history_get_entry(int index);
+
+/**
+ * @brief          Stop the periodic sampling task
+ *
+ * @retval         None
+ */
+void elm327_history_deinit(void);
+
+#endif // ELM327_HISTORY_H

MCP_servers/W600-embedded-OBD2/Include/App/mcp_http.h

@@ -0,0 +1,93 @@
+/**
+ * @file    mcp_http.h
+ *
+ * @brief   HTTP Protocol Handling for MCP Server
+ *
+ * This module provides HTTP request parsing and response building utilities
+ * for the MCP server.
+ */
+#ifndef MCP_HTTP_H
+#define MCP_HTTP_H
+
+#include "wm_type_def.h"
+
+// Configuration
+#define MCP_HTTP_MAX_REQUEST_SIZE   2048
+#define MCP_HTTP_MAX_HEADER_SIZE    512
+#define MCP_HTTP_MAX_PATH_SIZE      64
+#define MCP_HTTP_MAX_METHOD_SIZE    16
+
+/**
+ * HTTP request structure
+ */
+typedef struct {
+    char method[MCP_HTTP_MAX_METHOD_SIZE];           // "GET", "POST"
+    char path[MCP_HTTP_MAX_PATH_SIZE];               // "/mcp"
+    char protocol_version[32];                       // MCP-Protocol-Version header
+    char accept[128];                                // Accept header
+    char *body;                                      // Request body (points into buffer)
+    u32 body_len;                                    // Body length
+} mcp_http_request_t;
+
+/**
+ * HTTP response structure
+ */
+typedef struct {
+    int status_code;                                 // HTTP status code
+    const char *status_text;                         // Status text
+    const char *content_type;                        // Content-Type header
+    const char *body;                                // Response body
+    u32 body_len;                                    // Body length
+} mcp_http_response_t;
+
+/**
+ * @brief          Parse HTTP request from buffer
+ *
+ * @param[in]      buffer      Buffer containing HTTP request
+ * @param[in]      len         Length of buffer
+ * @param[out]     request     Parsed request structure
+ * @return         WM_SUCCESS on success, WM_FAILED on parse error
+ *
+ * @note           request->body will point into the buffer
+ */
+int mcp_http_parse_request(const char *buffer, u32 len, mcp_http_request_t *request);
+
+/**
+ * @brief          Build HTTP response string
+ *
+ * @param[in]      response    Response structure
+ * @param[out]     buffer      Buffer to write response to
+ * @param[in]      buffer_size Size of buffer
+ * @return         Number of bytes written, or -1 on error
+ */
+int mcp_http_build_response(const mcp_http_response_t *response, char *buffer, u32 buffer_size);
+
+/**
+ * @brief          Get HTTP status text for status code
+ *
+ * @param[in]      status_code HTTP status code
+ * @return         Status text string
+ */
+const char* mcp_http_get_status_text(int status_code);
+
+/**
+ * @brief          Check if request has required MCP headers
+ *
+ * @param[in]      request     HTTP request structure
+ * @return         1 if valid, 0 if missing required headers
+ */
+int mcp_http_validate_headers(const mcp_http_request_t *request);
+
+/**
+ * @brief          Parse Content-Length header from HTTP request buffer
+ *
+ * @param[in]      buffer          Buffer containing HTTP request
+ * @param[in]      len             Length of buffer
+ * @param[out]     content_length  Parsed Content-Length value
+ * @return         WM_SUCCESS if found and parsed, WM_FAILED if not found
+ *
+ * @note           If header is not found, content_length is set to 0
+ */
+int mcp_http_get_content_length(const char *buffer, u32 len, u32 *content_length);
+
+#endif // MCP_HTTP_H

MCP_servers/W600-embedded-OBD2/Include/App/mcp_jsonrpc.h

@@ -0,0 +1,79 @@
+/**
+ * @file    mcp_jsonrpc.h
+ *
+ * @brief   JSON-RPC 2.0 Message Handling
+ *
+ * This module handles parsing, dispatching, and building JSON-RPC 2.0 messages
+ * as used by the MCP protocol.
+ */
+#ifndef MCP_JSONRPC_H
+#define MCP_JSONRPC_H
+
+#include "wm_type_def.h"
+#include "cJSON.h"
+
+/**
+ * JSON-RPC message types
+ */
+typedef enum {
+    JSONRPC_REQUEST,       // Request expecting a response
+    JSONRPC_NOTIFICATION,  // Request not expecting a response (no id)
+    JSONRPC_RESPONSE       // Response to a request
+} mcp_jsonrpc_type_t;
+
+/**
+ * JSON-RPC request/notification structure
+ */
+typedef struct {
+    mcp_jsonrpc_type_t type;    // Message type
+    char *method;                // Method name (owned by this struct)
+    cJSON *params;               // Parameters object (owned by this struct)
+    cJSON *id;                   // Request ID (owned, NULL for notifications)
+} mcp_jsonrpc_request_t;
+
+/**
+ * @brief          Parse JSON-RPC message from string
+ *
+ * @param[in]      json_str    JSON string to parse
+ * @param[out]     request     Parsed request structure (caller must free)
+ * @return         WM_SUCCESS on success, WM_FAILED on parse error
+ *
+ * @note           Caller must call mcp_jsonrpc_free_request() when done
+ */
+int mcp_jsonrpc_parse(const char *json_str, mcp_jsonrpc_request_t *request);
+
+/**
+ * @brief          Free parsed request structure
+ *
+ * @param[in]      request     Request structure to free
+ */
+void mcp_jsonrpc_free_request(mcp_jsonrpc_request_t *request);
+
+/**
+ * @brief          Build JSON-RPC success response
+ *
+ * @param[in]      id          Request ID (cJSON object)
+ * @param[in]      result      Result object (takes ownership)
+ * @return         JSON string of response (caller must free)
+ */
+char* mcp_jsonrpc_build_response(cJSON *id, cJSON *result);
+
+/**
+ * @brief          Build JSON-RPC error response
+ *
+ * @param[in]      id          Request ID (cJSON object, can be NULL)
+ * @param[in]      code        Error code
+ * @param[in]      message     Error message
+ * @param[in]      data        Optional error data (can be NULL)
+ * @return         JSON string of error response (caller must free)
+ */
+char* mcp_jsonrpc_build_error(cJSON *id, int code, const char *message, cJSON *data);
+
+// Standard JSON-RPC error codes
+#define JSONRPC_PARSE_ERROR      -32700
+#define JSONRPC_INVALID_REQUEST  -32600
+#define JSONRPC_METHOD_NOT_FOUND -32601
+#define JSONRPC_INVALID_PARAMS   -32602
+#define JSONRPC_INTERNAL_ERROR   -32603
+
+#endif // MCP_JSONRPC_H

MCP_servers/W600-embedded-OBD2/Include/App/mcp_methods.h

@@ -0,0 +1,66 @@
+/**
+ * @file    mcp_methods.h
+ *
+ * @brief   MCP Protocol Methods
+ *
+ * This module implements the core MCP protocol methods:
+ * - initialize
+ * - tools/list
+ * - tools/call
+ */
+#ifndef MCP_METHODS_H
+#define MCP_METHODS_H
+
+#include "wm_type_def.h"
+#include "cJSON.h"
+
+/**
+ * @brief          Handle 'initialize' method
+ *
+ * @param[in]      params   Method parameters
+ * @param[out]     result   Method result (caller takes ownership, will be freed
+ *                          when passed to mcp_jsonrpc_build_response)
+ * @param[out]     error    Error object if method fails (caller takes ownership,
+ *                          will be freed when passed to mcp_jsonrpc_build_error)
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ */
+int mcp_method_initialize(cJSON *params, cJSON **result, cJSON **error);
+
+/**
+ * @brief          Handle 'tools/list' method
+ *
+ * @param[in]      params   Method parameters (unused)
+ * @param[out]     result   Method result (caller takes ownership, will be freed
+ *                          when passed to mcp_jsonrpc_build_response)
+ * @param[out]     error    Error object if method fails (caller takes ownership,
+ *                          will be freed when passed to mcp_jsonrpc_build_error)
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ */
+int mcp_method_tools_list(cJSON *params, cJSON **result, cJSON **error);
+
+/**
+ * @brief          Handle 'tools/call' method
+ *
+ * @param[in]      params   Method parameters (must contain 'name' and 'arguments')
+ * @param[out]     result   Method result (caller takes ownership, will be freed
+ *                          when passed to mcp_jsonrpc_build_response)
+ * @param[out]     error    Error object if method fails (caller takes ownership,
+ *                          will be freed when passed to mcp_jsonrpc_build_error)
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ */
+int mcp_method_tools_call(cJSON *params, cJSON **result, cJSON **error);
+
+/**
+ * @brief          Dispatch method by name
+ *
+ * @param[in]      method   Method name
+ * @param[in]      params   Method parameters
+ * @param[out]     result   Method result (caller takes ownership, will be freed
+ *                          when passed to mcp_jsonrpc_build_response)
+ * @param[out]     error    Error object if method fails (caller takes ownership,
+ *                          will be freed when passed to mcp_jsonrpc_build_error)
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ */
+int mcp_methods_dispatch(const char *method, cJSON *params, cJSON **result, cJSON **error);
+
+#endif // MCP_METHODS_H

MCP_servers/W600-embedded-OBD2/Include/App/mcp_server.h

@@ -0,0 +1,45 @@
+/**
+ * @file    mcp_server.h
+ *
+ * @brief   MCP (Model Context Protocol) HTTP Server
+ *
+ * This module implements a Streamable HTTP MCP Server that provides
+ * JSON-RPC endpoints for MCP clients to interact with the W600 device.
+ *
+ * The server exposes the /mcp endpoint:
+ * - POST /mcp: Handle JSON-RPC requests (initialize, tools/list, tools/call)
+ * - GET /mcp: Return 405 Method Not Allowed (SSE not supported)
+ */
+#ifndef MCP_SERVER_H
+#define MCP_SERVER_H
+
+#include "wm_type_def.h"
+
+/**
+ * @brief          Initialize and start MCP server
+ *
+ * @param[in]      port        Port to listen on (default: 80)
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ *
+ * @note           Server runs in LwIP context, no separate thread created
+ */
+int mcp_server_init(u16 port);
+
+/**
+ * @brief          Stop MCP server and cleanup resources
+ *
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ */
+int mcp_server_deinit(void);
+
+/**
+ * @brief          Check if MCP server is running
+ *
+ * @return         1 if running, 0 if not running
+ */
+int mcp_server_is_running(void);
+
+// Default port
+#define MCP_SERVER_DEFAULT_PORT  80
+
+#endif // MCP_SERVER_H

MCP_servers/W600-embedded-OBD2/Include/App/mcp_stream.h

@@ -0,0 +1,97 @@
+/**
+ * @file    mcp_stream.h
+ *
+ * @brief   MCP Streaming Response Support
+ *
+ * This module provides support for streaming large responses using
+ * chunked sends. This allows sending data that doesn't fit in memory
+ * all at once (e.g., ring buffers, logs, historical data).
+ */
+#ifndef MCP_STREAM_H
+#define MCP_STREAM_H
+
+#include "wm_type_def.h"
+#include "cJSON.h"
+
+/**
+ * Streaming context for chunked response generation
+ */
+typedef struct {
+    int socket;                    // Socket to send to
+    int error;                     // Error flag
+    int item_count;                // Number of items sent so far
+    int total_items;               // Total items to send (-1 if unknown)
+} mcp_stream_ctx_t;
+
+/**
+ * Streaming callback function type
+ *
+ * Called repeatedly to generate chunks of data.
+ *
+ * @param ctx      Streaming context
+ * @param user_data User data passed to mcp_stream_response()
+ * @return         WM_SUCCESS to continue, WM_FAILED to stop
+ */
+typedef int (*mcp_stream_callback_t)(mcp_stream_ctx_t *ctx, void *user_data);
+
+/**
+ * @brief          Initialize streaming context
+ *
+ * @param[out]     ctx          Streaming context to initialize
+ * @param[in]      socket       Socket to stream to
+ * @param[in]      total_items  Total items to stream (-1 if unknown)
+ */
+void mcp_stream_init(mcp_stream_ctx_t *ctx, int socket, int total_items);
+
+/**
+ * @brief          Send a chunk of text data
+ *
+ * @param[in]      ctx          Streaming context
+ * @param[in]      text         Text to send
+ * @param[in]      len          Length of text (-1 to use strlen)
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ *
+ * @note           This is a low-level function. Prefer mcp_stream_json_item()
+ *                 for structured data.
+ */
+int mcp_stream_send_chunk(mcp_stream_ctx_t *ctx, const char *text, int len);
+
+/**
+ * @brief          Send a JSON array item as a string
+ *
+ * Handles comma separation automatically.
+ *
+ * @param[in]      ctx          Streaming context
+ * @param[in]      json_str     JSON string for this item
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ */
+int mcp_stream_json_item(mcp_stream_ctx_t *ctx, const char *json_str);
+
+/**
+ * @brief          Send streaming JSON-RPC response
+ *
+ * Sends HTTP headers, opens JSON-RPC structure, calls callback repeatedly
+ * to generate content, then closes JSON-RPC structure.
+ *
+ * @param[in]      socket       Socket to send to
+ * @param[in]      request_id   JSON-RPC request ID (cJSON object)
+ * @param[in]      callback     Callback to generate content chunks
+ * @param[in]      user_data    User data passed to callback
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ *
+ * Example callback that streams 100 items:
+ *
+ *   int my_callback(mcp_stream_ctx_t *ctx, void *user_data) {
+ *       char buf[128];
+ *       if (ctx->item_count >= 100) {
+ *           return WM_FAILED;  // Done
+ *       }
+ *       snprintf(buf, sizeof(buf), "{\"id\":%d,\"value\":%d}",
+ *                ctx->item_count, ctx->item_count * 2);
+ *       return mcp_stream_json_item(ctx, buf);
+ *   }
+ */
+int mcp_stream_response(int socket, cJSON *request_id,
+                        mcp_stream_callback_t callback, void *user_data);
+
+#endif // MCP_STREAM_H

MCP_servers/W600-embedded-OBD2/Include/App/mcp_tools.h

@@ -0,0 +1,58 @@
+/**
+ * @file    mcp_tools.h
+ *
+ * @brief   MCP Tools Implementation
+ *
+ * This module defines and implements the tools exposed by the MCP server.
+ * Currently supports: status and send_elm327_command tools.
+ */
+#ifndef MCP_TOOLS_H
+#define MCP_TOOLS_H
+
+#include "wm_type_def.h"
+#include "cJSON.h"
+
+/**
+ * Tool handler function type
+ *
+ * @param[in]  args     Tool arguments as cJSON object
+ * @param[out] result   Tool result to be returned (caller must free)
+ * @param[out] error    Error object if tool fails (caller must free)
+ * @return              WM_SUCCESS on success, WM_FAILED on error
+ */
+typedef int (*mcp_tool_handler_t)(cJSON *args, cJSON **result, cJSON **error);
+
+/**
+ * Tool definition structure
+ */
+typedef struct {
+    const char *name;                  // Tool name
+    const char *description;           // Tool description
+    const char *input_schema_json;     // JSON Schema as string
+    mcp_tool_handler_t handler;        // Handler function
+} mcp_tool_t;
+
+/**
+ * @brief          Get list of available tools
+ *
+ * @param[out]     count    Number of tools returned
+ * @return         Pointer to array of tool definitions
+ */
+const mcp_tool_t* mcp_tools_get_list(int *count);
+
+/**
+ * @brief          Find tool by name
+ *
+ * @param[in]      name     Tool name to find
+ * @return         Pointer to tool definition, or NULL if not found
+ */
+const mcp_tool_t* mcp_tools_find(const char *name);
+
+/**
+ * @brief          Initialize tools subsystem
+ *
+ * @return         WM_SUCCESS on success, WM_FAILED on error
+ */
+int mcp_tools_init(void);
+
+#endif // MCP_TOOLS_H

MCP_servers/W600-embedded-OBD2/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2025 David Robert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MCP_servers/W600-embedded-OBD2/README.md

@@ -0,0 +1,424 @@
+# W600 Embedded OBD2 MCP Server
+
+An embedded Model Context Protocol (MCP) server implementation for the W600 WiFi SoC, providing vehicle diagnostics capabilities through ELM327 OBD-II interface over HTTP.
+
+## Hackathon
+
+This was created as part of our submission for the Anthropic Gradio MCP's 1st Birthday hackathon: https://huggingface.co/spaces/MCP-1st-Birthday/Vehicle-Diagnostic-Assistant
+
+## Overview
+
+This project implements an MCP server that runs directly on the W600 microcontroller, enabling vehicle diagnostic communication through the ELM327 OBD-II protocol. The server exposes MCP tools over HTTP, allowing AI assistants and other clients to query vehicle data, read diagnostic trouble codes (DTCs), and perform OBD-II operations wirelessly.
+
+## Features
+
+- **MCP Server Implementation**: Full JSON-RPC 2.0 based MCP server running on W600
+- **ELM327 Support**: Complete ELM327 OBD-II command interface with UART communication
+- **OBD-II Simulation**: Built-in simulator for testing without vehicle connection
+- **WiFi Connectivity**: Connect via WiFi access point or station mode
+- **HTTP Interface**: RESTful HTTP endpoint for MCP communication
+- **OTA Updates**: Over-the-air firmware update capability
+- **Logging**: EasyLogger integration for comprehensive debug logging
+
+## Hardware Requirements
+
+- W600 WiFi SoC development board
+- ELM327 OBD-II interface module (UART-based)
+- Vehicle with OBD-II port (for actual diagnostics)
+- USB-to-Serial adapter (for programming and debugging)
+
+## Software Requirements
+
+- W600 SDK (required)
+- GNU ARM toolchain (included with W600 SDK)
+- Serial terminal software (for debugging)
+
+## Installation
+
+### 1. Install W600 SDK
+
+Download and install the W600 SDK from the official WinnerMicro website or GitHub repository. Follow the SDK installation instructions for your operating system.
+
+### 2. Copy Project Files
+
+Copy the files from this repository into the corresponding folders in your W600 SDK installation:
+
+- **`App/`** folder contents → Copy to `{W600_SDK}/App/`
+
+  - `main.c` - Main application entry point
+  - `wm_app_config.h` - Application configuration
+  - `wifi_credentials.h.template` - WiFi credentials template
+
+- **`Src/App/`** folder contents → Copy to `{W600_SDK}/Src/App/`
+  - `easylogger/` - Logging library
+  - `elm327/` - ELM327 driver and simulator
+  - `mcp/` - MCP server implementation
+
+### 3. Configure WiFi Credentials
+
+1. Copy the template file:
+
+   ```bash
+   cp App/wifi_credentials.h.template App/wifi_credentials.h
+   ```
+
+2. Edit `App/wifi_credentials.h` and add your WiFi credentials:
+
+   ```c
+   #define WIFI_SSID "your_ssid"
+   #define WIFI_PASSWORD "your_password"
+   ```
+
+   **Note**: `wifi_credentials.h` is gitignored to protect your credentials.
+
+### 4. Configure Application Settings
+
+Edit `App/wm_app_config.h` to configure:
+
+- **Firmware Update Server**: Set `FIRMWARE_SERVER` URL for OTA updates
+- **MCP Server Port**: Default is port 80
+- **ELM327 Settings**: UART configuration for ELM327 communication
+
+### 5. Build the Project
+
+Navigate to the W600 SDK build directory and compile:
+
+```bash
+cd {W600_SDK}/Tools/GNU
+make clean
+make
+```
+
+This will generate the firmware image in the `Bin/` directory.
+
+### 6. Flash the Firmware
+
+Flash the compiled firmware to your W600 board using the W600 flash tool:
+
+```bash
+# Example using wm_tool (adjust COM port as needed)
+wm_tool -c COM3 -ds 1M -dl {W600_SDK}/Bin/W600.fls
+```
+
+## Configuration
+
+### ELM327 Simulation Mode
+
+The project includes an OBD-II simulator for testing without a vehicle. To configure:
+
+Edit `Include/wm_config.h` in the W600 SDK:
+
+```c
+/** ELM327 OBD-II **/
+#define TLS_CONFIG_ELM327_SIMULATION    CFG_ON   // Enable simulator
+// or
+#define TLS_CONFIG_ELM327_SIMULATION    CFG_OFF  // Disable (use real ELM327)
+```
+
+See `Src/App/elm327/README_SIMULATION.md` for detailed simulation documentation.
+
+### Network Configuration
+
+The device can be configured for:
+
+- **Station Mode**: Connect to existing WiFi network (default)
+- **AP Mode**: Create its own access point
+
+Configure in `App/main.c` by modifying the WiFi initialization code.
+
+## Usage
+
+### Starting the Server
+
+1. Power on the W600 board
+2. The device will connect to WiFi using configured credentials
+3. Monitor serial output for the assigned IP address
+4. MCP server starts automatically on port 80
+
+### Accessing the MCP Server
+
+The MCP server accepts JSON-RPC 2.0 requests at:
+
+```
+http://{device_ip}/mcp
+```
+
+### Example MCP Requests
+
+#### Get System Status
+
+```bash
+curl -X POST http://192.168.1.100/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "method": "tools/call",
+    "params": {
+      "name": "status"
+    },
+    "id": 1
+  }'
+```
+
+Response includes: IP address, uptime, free memory, WiFi RSSI, and ELM327 status.
+
+#### Send ELM327 Command
+
+```bash
+curl -X POST http://192.168.1.100/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "method": "tools/call",
+    "params": {
+      "name": "send_elm327_command",
+      "arguments": {
+        "command": "01 0C"
+      }
+    },
+    "id": 2
+  }'
+```
+
+#### Get Vehicle Speed
+
+```bash
+curl -X POST http://192.168.1.100/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "method": "tools/call",
+    "params": {
+      "name": "send_elm327_command",
+      "arguments": {
+        "command": "01 0D"
+      }
+    },
+    "id": 3
+  }'
+```
+
+#### Read Diagnostic Trouble Codes
+
+```bash
+curl -X POST http://192.168.1.100/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "method": "tools/call",
+    "params": {
+      "name": "send_elm327_command",
+      "arguments": {
+        "command": "03"
+      }
+    },
+    "id": 4
+  }'
+```
+
+#### Get Historical OBD-II Data
+
+```bash
+curl -X POST http://192.168.1.100/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "method": "tools/call",
+    "params": {
+      "name": "get_elm327_history",
+      "arguments": {
+        "count": 50
+      }
+    },
+    "id": 5
+  }'
+```
+
+Returns historical log of RPM, speed, and coolant temperature. Omit `count` or set to 0 for all records.
+
+## Project Structure
+
+```
+W600-embedded-OBD2/
+├── App/
+│   ├── main.c                          # Main application entry point
+│   ├── wm_app_config.h                 # Application configuration
+│   └── wifi_credentials.h.template     # WiFi credentials template
+│
+├── Src/App/
+│   ├── easylogger/                     # Logging library
+│   │   ├── inc/                        # Header files
+│   │   ├── port/                       # W600 port implementation
+│   │   └── src/                        # Logger source code
+│   │
+│   ├── elm327/                         # ELM327 OBD-II driver
+│   │   ├── elm327.c                    # Main driver with simulation
+│   │   ├── elm327_sim.c                # OBD-II simulator
+│   │   ├── elm327_sim.h                # Simulator header
+│   │   ├── elm327_history.c            # Command history
+│   │   └── README_SIMULATION.md        # Simulation documentation
+│   │
+│   └── mcp/                            # MCP server implementation
+│       ├── mcp_server.c                # Main server logic
+│       ├── mcp_http.c                  # HTTP request handling
+│       ├── mcp_jsonrpc.c               # JSON-RPC protocol
+│       ├── mcp_methods.c               # MCP method handlers
+│       ├── mcp_tools.c                 # MCP tool definitions
+│       └── mcp_stream.c                # Stream utilities
+│
+├── LICENSE
+└── README.md                           # This file
+```
+
+## Available MCP Tools
+
+The server exposes the following MCP tools:
+
+### 1. `status`
+
+Get system status information including network, hardware, and ELM327 status.
+
+- **Parameters**: None
+- **Returns**: JSON object with:
+  - `ip_address` - Device IP address
+  - `uptime_seconds` - System uptime in seconds
+  - `free_memory_bytes` - Available heap memory
+  - `wifi_rssi_dbm` - WiFi signal strength (dBm)
+  - `elm327_status` - ELM327 connection status
+
+### 2. `send_elm327_command`
+
+Send a command to the ELM327 OBD-II adapter and receive the response.
+
+- **Parameters**:
+  - `command` (string, required) - ELM327 command to send (e.g., "ATZ", "01 0C", "03")
+- **Returns**: Text response from ELM327 adapter
+- **Example commands**:
+  - `"ATZ"` - Reset ELM327
+  - `"01 0C"` - Get engine RPM
+  - `"01 0D"` - Get vehicle speed
+  - `"03"` - Read stored DTCs
+
+### 3. `get_elm327_history`
+
+Retrieve historical log of OBD-II data (RPM, speed, coolant temperature) with streaming support.
+
+- **Parameters**:
+  - `count` (number, optional) - Number of most recent records to retrieve
+    - Default: 100
+    - Set to 0 for all available records
+- **Returns**: Array of historical data entries, each containing:
+  - `seq` - Sequence number
+  - `time` - Timestamp in seconds
+  - `rpm` - Engine RPM
+  - `speed` - Vehicle speed (km/h)
+  - `coolant_temp` - Coolant temperature (°C)
+
+**Note**: This tool uses streaming to efficiently handle large datasets.
+
+### Adding Custom Tools
+
+Additional tools can be added by:
+
+1. Defining the tool handler in `Src/App/mcp/mcp_tools.c`
+2. Adding the tool definition to the `tools[]` array
+3. Rebuilding and flashing the firmware
+
+## Development
+
+### Adding New MCP Tools
+
+1. Define tool schema in `Src/App/mcp/mcp_tools.c`
+2. Implement handler in `Src/App/mcp/mcp_methods.c`
+3. Register method in the method dispatch table
+4. Rebuild and flash firmware
+
+### Debugging
+
+Serial debug output is available at 115200 baud. Use a serial terminal to view logs:
+
+```bash
+# Linux/Mac
+screen /dev/ttyUSB0 115200
+
+# Windows
+putty -serial COM3 -sercfg 115200,8,n,1,N
+```
+
+### OTA Updates
+
+To perform OTA firmware update:
+
+1. Build new firmware
+2. Host the `.fls` file on your firmware server
+3. Configure `FIRMWARE_SERVER` and `FIRMWARE_FILENAME` in `wm_app_config.h`
+4. The device will check for updates on boot
+5. If available, firmware will be downloaded and applied automatically
+
+## Supported OBD-II PIDs
+
+When using the simulator or real ELM327, the following PIDs are supported:
+
+### Mode 01 (Current Data)
+
+- `01 0C` - Engine RPM
+- `01 0D` - Vehicle Speed
+- `01 05` - Engine Coolant Temperature
+- `01 04` - Calculated Engine Load
+- `01 0F` - Intake Air Temperature
+- And many more (see simulation documentation)
+
+### Mode 03
+
+- `03` - Read stored diagnostic trouble codes
+
+### Mode 04
+
+- `04` - Clear diagnostic trouble codes
+
+### Mode 07
+
+- `07` - Read pending diagnostic trouble codes
+
+### Mode 09 (Vehicle Information)
+
+- `09 02` - Vehicle Identification Number (VIN)
+- `09 04` - Calibration ID
+- `09 0A` - ECU Name
+
+For complete PID list, see `Src/App/elm327/README_SIMULATION.md`.
+
+## Troubleshooting
+
+### WiFi Connection Issues
+
+- Verify WiFi credentials in `wifi_credentials.h`
+- Check serial output for connection status
+- Ensure WiFi network is 2.4GHz (W600 does not support 5GHz)
+
+### ELM327 Communication Issues
+
+- Check UART wiring (TX, RX, GND)
+- Verify baud rate configuration (default 9600 or 38400)
+- Enable simulation mode for testing without hardware
+
+### MCP Server Not Responding
+
+- Verify device IP address from serial output
+- Check firewall settings
+- Ensure HTTP port 80 is accessible
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests.
+
+## References
+
+- [Model Context Protocol (MCP) Specification](https://spec.modelcontextprotocol.io/)
+- [ELM327 Command Reference](https://www.elmelectronics.com/wp-content/uploads/2016/07/ELM327DS.pdf)
+- [OBD-II PIDs](https://en.wikipedia.org/wiki/OBD-II_PIDs)
+- W600 SDK Documentation

MCP_servers/W600-embedded-OBD2/Src/App/easylogger/Makefile

@@ -0,0 +1,52 @@
+#/**************************************************************************
+# * Kevin 2014-02-24                                                       *
+# **************************************************************************/
+
+#---------------------------------------------------------------------------
+# Constant Variable definition
+#---------------------------------------------------------------------------
+
+ifeq ($(COMPILER_OS_CYGWIN),1)
+TOPDIR=../../..
+endif
+
+include $(TOPDIR)/Tools/toolchain.def
+
+#---------------------------------------------------------------------------
+# Target definition (User)
+#---------------------------------------------------------------------------
+GOAL  = $(LIB_DIR)/wmeasylogger.$(LIBTYPE)
+
+#---------------------------------------------------------------------------
+# Source section (User)
+#---------------------------------------------------------------------------
+ASM_SRC			+= 
+C_SRC			+= src/elog.c
+C_SRC			+= src/elog_async.c
+C_SRC			+= src/elog_buf.c
+C_SRC			+= src/elog_utils.c
+C_SRC			+= port/elog_port.c
+#---------------------------------------------------------------------------
+# Implicit rules
+#---------------------------------------------------------------------------
+.c.o:
+	$(CC) $(CFLAGS) -c -o $*.o $< $(INCLUDES)
+
+.s.o:
+	$(ASM) $(ASMFLAGS) -c -o $*.o $< $(INCLUDES)
+
+#---------------------------------------------------------------------------
+# Explicit ruls
+#---------------------------------------------------------------------------
+OBJ_FILES	= $(C_SRC:%.c=%.o) $(ASM_SRC:%.s=%.o)
+
+all: $(GOAL)
+
+$(GOAL): $(OBJ_FILES)
+	$(AR) $(ARFLAGS) $@ $(OBJ_FILES)
+	
+.PHONY: clean
+clean:
+	$(RM) -f $(GOAL)
+	$(RM) -f $(OBJ_FILES:.o=.d) $(OBJ_FILES)
+	

MCP_servers/W600-embedded-OBD2/Src/App/easylogger/inc/elog.h

@@ -0,0 +1,260 @@
+/*
+ * This file is part of the EasyLogger Library.
+ *
+ * Copyright (c) 2015-2019, Armink, <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: It is an head file for this library. You can see all be called functions.
+ * Created on: 2015-04-28
+ */
+
+#ifndef __ELOG_H__
+#define __ELOG_H__
+
+#include <elog_cfg.h>
+#include <stdint.h>
+#include <stddef.h>
+//#include <stdbool.h>
+#include "wm_type_def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* output log's level */
+#define ELOG_LVL_ASSERT                      0
+#define ELOG_LVL_ERROR                       1
+#define ELOG_LVL_WARN                        2
+#define ELOG_LVL_INFO                        3
+#define ELOG_LVL_DEBUG                       4
+#define ELOG_LVL_VERBOSE                     5
+
+/* output log's level total number */
+#define ELOG_LVL_TOTAL_NUM                   6
+
+/* EasyLogger software version number */
+#define ELOG_SW_VERSION                      "2.1.0"
+
+/* EasyLogger assert for developer. */
+#ifdef ELOG_ASSERT_ENABLE
+    #define ELOG_ASSERT(EXPR)                                                 \
+    if (!(EXPR))                                                              \
+    {                                                                         \
+        if (elog_assert_hook == NULL) {                                       \
+            elog_a("elog", "(%s) has assert failed at %s:%ld.", #EXPR, __FUNCTION__, __LINE__); \
+            while (1);                                                        \
+        } else {                                                              \
+            elog_assert_hook(#EXPR, __FUNCTION__, __LINE__);                  \
+        }                                                                     \
+    }
+#else
+    #define ELOG_ASSERT(EXPR)                    ((void)0);
+#endif
+
+#ifndef ELOG_OUTPUT_ENABLE
+    #define elog_assert(tag, ...)
+    #define elog_error(tag, ...)
+    #define elog_warn(tag, ...)
+    #define elog_info(tag, ...)
+    #define elog_debug(tag, ...)
+    #define elog_verbose(tag, ...)
+#else /* ELOG_OUTPUT_ENABLE */
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_ASSERT
+        #define elog_assert(tag, ...) \
+                elog_output(ELOG_LVL_ASSERT, tag, __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
+    #else
+        #define elog_assert(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_ASSERT */
+
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_ERROR
+        #define elog_error(tag, ...) \
+                elog_output(ELOG_LVL_ERROR, tag, __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
+    #else
+        #define elog_error(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_ERROR */
+
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_WARN
+        #define elog_warn(tag, ...) \
+                elog_output(ELOG_LVL_WARN, tag, __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
+    #else
+        #define elog_warn(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_WARN */
+
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_INFO
+        #define elog_info(tag, ...) \
+                elog_output(ELOG_LVL_INFO, tag, __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
+    #else
+        #define elog_info(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_INFO */
+
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_DEBUG
+        #define elog_debug(tag, ...) \
+                elog_output(ELOG_LVL_DEBUG, tag, __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
+    #else
+        #define elog_debug(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_DEBUG */
+
+    #if ELOG_OUTPUT_LVL == ELOG_LVL_VERBOSE
+        #define elog_verbose(tag, ...) \
+                elog_output(ELOG_LVL_VERBOSE, tag, __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
+    #else
+        #define elog_verbose(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL == ELOG_LVL_VERBOSE */
+#endif /* ELOG_OUTPUT_ENABLE */
+
+/* all formats index */
+typedef enum {
+    ELOG_FMT_LVL    = 1 << 0, /**< level */
+    ELOG_FMT_TAG    = 1 << 1, /**< tag */
+    ELOG_FMT_TIME   = 1 << 2, /**< current time */
+    ELOG_FMT_P_INFO = 1 << 3, /**< process info */
+    ELOG_FMT_T_INFO = 1 << 4, /**< thread info */
+    ELOG_FMT_DIR    = 1 << 5, /**< file directory and name */
+    ELOG_FMT_FUNC   = 1 << 6, /**< function name */
+    ELOG_FMT_LINE   = 1 << 7, /**< line number */
+} ElogFmtIndex;
+
+/* macro definition for all formats */
+#define ELOG_FMT_ALL    (ELOG_FMT_LVL|ELOG_FMT_TAG|ELOG_FMT_TIME|ELOG_FMT_P_INFO|ELOG_FMT_T_INFO| \
+    ELOG_FMT_DIR|ELOG_FMT_FUNC|ELOG_FMT_LINE)
+
+/* output log's filter */
+typedef struct {
+    uint8_t level;
+    char tag[ELOG_FILTER_TAG_MAX_LEN + 1];
+    char keyword[ELOG_FILTER_KW_MAX_LEN + 1];
+} ElogFilter, *ElogFilter_t;
+
+/* easy logger */
+typedef struct {
+    ElogFilter filter;
+    size_t enabled_fmt_set[ELOG_LVL_TOTAL_NUM];
+    bool output_enabled;
+    bool output_lock_enabled;
+    bool output_is_locked_before_enable;
+    bool output_is_locked_before_disable;
+
+#ifdef ELOG_COLOR_ENABLE
+    bool text_color_enabled;
+#endif
+
+}EasyLogger, *EasyLogger_t;
+
+/* EasyLogger error code */
+typedef enum {
+    ELOG_NO_ERR,
+    ELOG_ERR,
+} ElogErrCode;
+
+/* elog.c */
+ElogErrCode elog_init(void);
+void elog_start(void);
+void elog_set_output_enabled(bool enabled);
+bool elog_get_output_enabled(void);
+void elog_set_text_color_enabled(bool enabled);
+bool elog_get_text_color_enabled(void);
+void elog_set_fmt(uint8_t level, size_t set);
+void elog_set_filter(uint8_t level, const char *tag, const char *keyword);
+void elog_set_filter_lvl(uint8_t level);
+void elog_set_filter_tag(const char *tag);
+void elog_set_filter_kw(const char *keyword);
+void elog_raw(const char *format, ...);
+void elog_output(uint8_t level, const char *tag, const char *file, const char *func,
+        const long line, const char *format, ...);
+void elog_output_lock_enabled(bool enabled);
+extern void (*elog_assert_hook)(const char* expr, const char* func, size_t line);
+void elog_assert_set_hook(void (*hook)(const char* expr, const char* func, size_t line));
+int8_t elog_find_lvl(const char *log);
+const char *elog_find_tag(const char *log, uint8_t lvl, size_t *tag_len);
+void elog_hexdump(const char *name, uint8_t width, uint8_t *buf, uint16_t size);
+
+#define elog_a(tag, ...)     elog_assert(tag, __VA_ARGS__)
+#define elog_e(tag, ...)     elog_error(tag, __VA_ARGS__)
+#define elog_w(tag, ...)     elog_warn(tag, __VA_ARGS__)
+#define elog_i(tag, ...)     elog_info(tag, __VA_ARGS__)
+#define elog_d(tag, ...)     elog_debug(tag, __VA_ARGS__)
+#define elog_v(tag, ...)     elog_verbose(tag, __VA_ARGS__)
+
+/**
+ * log API short definition
+ * NOTE: The `LOG_TAG` and `LOG_LVL` must defined before including the <elog.h> when you want to use log_x API.
+ */
+#if !defined(LOG_TAG)
+    #define LOG_TAG          "None"
+#endif
+#if !defined(LOG_LVL)
+    #define LOG_LVL          ELOG_LVL_VERBOSE
+#endif
+#if LOG_LVL >= ELOG_LVL_ASSERT
+    #define log_a(...)       elog_a(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_a(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_ERROR
+    #define log_e(...)       elog_e(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_e(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_WARN
+    #define log_w(...)       elog_w(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_w(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_INFO
+    #define log_i(...)       elog_i(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_i(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_DEBUG
+    #define log_d(...)       elog_d(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_d(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_VERBOSE
+    #define log_v(...)       elog_v(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_v(...)       ((void)0);
+#endif
+
+/* assert API short definition */
+#if !defined(assert)
+    #define assert           ELOG_ASSERT
+#endif
+
+/* elog_buf.c */
+void elog_buf_enabled(bool enabled);
+void elog_flush(void);
+
+/* elog_async.c */
+void elog_async_enabled(bool enabled);
+size_t elog_async_get_log(char *log, size_t size);
+size_t elog_async_get_line_log(char *log, size_t size);
+
+/* elog_utils.c */
+size_t elog_strcpy(size_t cur_len, char *dst, const char *src);
+size_t elog_cpyln(char *line, const char *log, size_t len);
+void *elog_memcpy(void *dst, const void *src, size_t count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ELOG_H__ */

MCP_servers/W600-embedded-OBD2/Src/App/easylogger/inc/elog_cfg.h

@@ -0,0 +1,75 @@
+/*
+ * This file is part of the EasyLogger Library.
+ *
+ * Copyright (c) 2015-2016, Armink, <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: It is the configure head file for this library.
+ * Created on: 2015-07-30
+ */
+
+#ifndef _ELOG_CFG_H_
+#define _ELOG_CFG_H_
+/*---------------------------------------------------------------------------*/
+/* enable log output. */
+#define ELOG_OUTPUT_ENABLE
+/* setting static output log level. range: from ELOG_LVL_ASSERT to ELOG_LVL_VERBOSE */
+#define ELOG_OUTPUT_LVL                          ELOG_LVL_INFO
+/* enable assert check */
+#define ELOG_ASSERT_ENABLE
+/* buffer size for every line's log */
+#define ELOG_LINE_BUF_SIZE                       1024
+/* output line number max length */
+#define ELOG_LINE_NUM_MAX_LEN                    5
+/* output filter's tag max length */
+#define ELOG_FILTER_TAG_MAX_LEN                  30
+/* output filter's keyword max length */
+#define ELOG_FILTER_KW_MAX_LEN                   16
+/* output newline sign */
+#define ELOG_NEWLINE_SIGN                        "\n"
+/*---------------------------------------------------------------------------*/
+/* enable log color */
+#define ELOG_COLOR_ENABLE
+/* change the some level logs to not default color if you want */
+#define ELOG_COLOR_ASSERT                        (F_MAGENTA B_NULL S_NORMAL)
+#define ELOG_COLOR_ERROR                         (F_RED B_NULL S_NORMAL)
+#define ELOG_COLOR_WARN                          (F_YELLOW B_NULL S_NORMAL)
+#define ELOG_COLOR_INFO                          (F_CYAN B_NULL S_NORMAL)
+#define ELOG_COLOR_DEBUG                         (F_GREEN B_NULL S_NORMAL)
+#define ELOG_COLOR_VERBOSE                       (F_BLUE B_NULL S_NORMAL)
+/*---------------------------------------------------------------------------*/
+/* enable asynchronous output mode */
+//#define ELOG_ASYNC_OUTPUT_ENABLE
+/* the highest output level for async mode, other level will sync output */
+#define ELOG_ASYNC_OUTPUT_LVL                    ELOG_LVL_ASSERT
+/* buffer size for asynchronous output mode */
+#define ELOG_ASYNC_OUTPUT_BUF_SIZE               (ELOG_LINE_BUF_SIZE * 10)
+/* each asynchronous output's log which must end with newline sign */
+#define ELOG_ASYNC_LINE_OUTPUT
+/* asynchronous output mode using POSIX pthread implementation */
+#define ELOG_ASYNC_OUTPUT_USING_PTHREAD
+/*---------------------------------------------------------------------------*/
+/* enable buffered output mode */
+//#define ELOG_BUF_OUTPUT_ENABLE
+/* buffer size for buffered output mode */
+#define ELOG_BUF_OUTPUT_BUF_SIZE                 (ELOG_LINE_BUF_SIZE * 10)
+
+#endif /* _ELOG_CFG_H_ */

MCP_servers/W600-embedded-OBD2/Src/App/easylogger/port/elog_port.c

@@ -0,0 +1,444 @@
+/*
+ * This file is part of the EasyLogger Library.
+ *
+ * Copyright (c) 2015, Armink, <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Portable interface for each platform.
+ * Created on: 2015-04-28
+ */
+
+#include <elog.h>
+
+#include <string.h>
+#include "wm_include.h"
+#include "task.h"
+
+#if (TLS_CONFIG_UDP_SYSLOG == CFG_ON)
+#include "wm_sockets.h"
+#include <stdio.h>
+#endif
+
+#define ELOG_USE_TASK_OUTPUT       1
+
+#if ELOG_USE_TASK_OUTPUT
+
+#define ELOG_QUEUE_SIZE            32
+#define ELOG_TASK_PRIO             30
+#define ELOG_TASK_SIZE             256
+
+static tls_os_queue_t *elog_queue = NULL;
+
+static OS_STK elog_task_stk[ELOG_TASK_SIZE];
+
+#else /* ELOG_USE_TASK_OUTPUT */
+
+static tls_os_sem_t *elog_lock = NULL;
+
+#endif /* ELOG_USE_TASK_OUTPUT */
+
+#if (TLS_CONFIG_UDP_SYSLOG == CFG_ON)
+static int syslog_socket = -1;
+static struct sockaddr_in syslog_server;
+static bool syslog_initialized = FALSE;
+
+/* Syslog severity levels (RFC 3164) */
+#define SYSLOG_SEVERITY_EMERG     0  /* Emergency - system is unusable */
+#define SYSLOG_SEVERITY_ALERT     1  /* Alert - action must be taken immediately */
+#define SYSLOG_SEVERITY_CRIT      2  /* Critical */
+#define SYSLOG_SEVERITY_ERR       3  /* Error */
+#define SYSLOG_SEVERITY_WARNING   4  /* Warning */
+#define SYSLOG_SEVERITY_NOTICE    5  /* Notice - normal but significant */
+#define SYSLOG_SEVERITY_INFO      6  /* Informational */
+#define SYSLOG_SEVERITY_DEBUG     7  /* Debug */
+
+/* Syslog facility - user-level messages */
+#define SYSLOG_FACILITY_USER      1
+
+/* Calculate priority value: (facility * 8) + severity */
+#define SYSLOG_PRIORITY(facility, severity) ((facility << 3) | severity)
+
+/**
+ * Parse severity level from formatted log string
+ *
+ * @param log   Formatted log message
+ * @param size  Message size
+ * @return syslog severity (0-7)
+ */
+static int elog_parse_severity(const char *log, size_t size) {
+    int severity = SYSLOG_SEVERITY_INFO;  /* Default severity */
+
+    /* Try to extract severity from log prefix if available */
+    if (size > 2 && log[0] == '[') {
+        if (log[1] == 'A') severity = SYSLOG_SEVERITY_EMERG;   /* [A]ssert */
+        else if (log[1] == 'E') severity = SYSLOG_SEVERITY_ERR;      /* [E]rror */
+        else if (log[1] == 'W') severity = SYSLOG_SEVERITY_WARNING;  /* [W]arn */
+        else if (log[1] == 'I') severity = SYSLOG_SEVERITY_INFO;     /* [I]nfo */
+        else if (log[1] == 'D') severity = SYSLOG_SEVERITY_DEBUG;    /* [D]ebug */
+        else if (log[1] == 'V') severity = SYSLOG_SEVERITY_DEBUG;    /* [V]erbose */
+    }
+
+    return severity;
+}
+
+/**
+ * Send syslog message via UDP
+ *
+ * @param severity  Syslog severity level (0-7)
+ * @param log       Log message
+ * @param size      Message size
+ */
+static void elog_syslog_send(int severity, const char *log, size_t size) {
+    if (!syslog_initialized || syslog_socket < 0) {
+        return;
+    }
+
+    /* RFC 3164 syslog format: <PRI>TIMESTAMP HOSTNAME MESSAGE
+     * We use a simplified version without timestamp for embedded systems
+     * Format: <PRI>HOSTNAME: MESSAGE
+     *
+     * Use heap allocation to avoid stack overflow in task with limited stack
+     */
+    char *syslog_msg = tls_mem_alloc(512);
+    if (!syslog_msg) {
+        return;  /* Silently fail if out of memory */
+    }
+
+    int priority = SYSLOG_PRIORITY(SYSLOG_FACILITY_USER, severity);
+
+    /* Build syslog message */
+    int len = snprintf(syslog_msg, 512, "<%d>%s: %.*s",
+                       priority, TLS_CONFIG_UDP_SYSLOG_HOSTNAME, (int)size, log);
+
+    if (len > 0 && len < 512) {
+        /* Send to syslog server - non-blocking, we don't care if it fails */
+        sendto(syslog_socket, syslog_msg, len, 0,
+               (struct sockaddr *)&syslog_server, sizeof(syslog_server));
+    }
+
+    tls_mem_free(syslog_msg);
+}
+#endif
+
+
+#if ELOG_USE_TASK_OUTPUT
+static void elog_task_entry(void *data)
+{
+    int  ret;
+    void *msg;
+
+    for( ; ; )
+	{
+		ret = tls_os_queue_receive(elog_queue, (void **)&msg, 0, 0);
+		if (TLS_OS_SUCCESS == ret)
+		{
+            char *log_msg = (char *)msg;
+            size_t log_size = strlen(log_msg);
+
+            /* Output to console */
+            printf("%s", log_msg);
+
+#if (TLS_CONFIG_UDP_SYSLOG == CFG_ON)
+            /* Send to UDP syslog server (safe from task context) */
+            if (syslog_initialized && syslog_socket >= 0) {
+                int severity = elog_parse_severity(log_msg, log_size);
+                elog_syslog_send(severity, log_msg, log_size);
+            }
+#endif
+
+            tls_mem_free(msg);
+		}
+	}
+}
+#endif
+
+#if (TLS_CONFIG_UDP_SYSLOG == CFG_ON)
+/**
+ * Initialize UDP syslog
+ *
+ * @return 0 on success, -1 on failure
+ */
+static int elog_syslog_init(void) {
+    /* Create UDP socket */
+    syslog_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if (syslog_socket < 0) {
+        printf("Failed to create syslog socket\r\n");
+        return -1;
+    }
+
+    /* Set socket to non-blocking mode to avoid blocking on send */
+    int flags = 1;
+    if (ioctlsocket(syslog_socket, FIONBIO, &flags) < 0) {
+        printf("Failed to set syslog socket non-blocking\r\n");
+        closesocket(syslog_socket);
+        syslog_socket = -1;
+        return -1;
+    }
+
+    /* Configure syslog server address */
+    memset(&syslog_server, 0, sizeof(syslog_server));
+    syslog_server.sin_family = AF_INET;
+    syslog_server.sin_port = htons(TLS_CONFIG_UDP_SYSLOG_SERVER_PORT);
+    syslog_server.sin_addr.s_addr = ipaddr_addr(TLS_CONFIG_UDP_SYSLOG_SERVER_IP);
+
+    syslog_initialized = TRUE;
+    printf("UDP Syslog initialized - Server: %s:%d\r\n",
+           TLS_CONFIG_UDP_SYSLOG_SERVER_IP, TLS_CONFIG_UDP_SYSLOG_SERVER_PORT);
+
+    return 0;
+}
+
+/**
+ * Map EasyLogger level to syslog severity
+ *
+ * @param level  EasyLogger level
+ * @return syslog severity (0-7)
+ */
+static int elog_level_to_syslog_severity(uint8_t level) {
+    switch (level) {
+        case ELOG_LVL_ASSERT:
+            return SYSLOG_SEVERITY_EMERG;
+        case ELOG_LVL_ERROR:
+            return SYSLOG_SEVERITY_ERR;
+        case ELOG_LVL_WARN:
+            return SYSLOG_SEVERITY_WARNING;
+        case ELOG_LVL_INFO:
+            return SYSLOG_SEVERITY_INFO;
+        case ELOG_LVL_DEBUG:
+            return SYSLOG_SEVERITY_DEBUG;
+        case ELOG_LVL_VERBOSE:
+            return SYSLOG_SEVERITY_DEBUG;
+        default:
+            return SYSLOG_SEVERITY_NOTICE;
+    }
+}
+
+/**
+ * Cleanup UDP syslog
+ */
+static void elog_syslog_deinit(void) {
+    if (syslog_socket >= 0) {
+        closesocket(syslog_socket);
+        syslog_socket = -1;
+    }
+    syslog_initialized = FALSE;
+}
+#endif
+
+/**
+ * EasyLogger port initialize
+ *
+ * @return result
+ */
+ElogErrCode elog_port_init(void) {
+    ElogErrCode result = ELOG_NO_ERR;
+
+    /* add your code here */
+    int ret = TLS_OS_SUCCESS;
+
+#if ELOG_USE_TASK_OUTPUT
+    ret |= tls_os_queue_create(&elog_queue, ELOG_QUEUE_SIZE);
+
+    ret |= tls_os_task_create(NULL, NULL, elog_task_entry,
+                             (void *)0, (void *)elog_task_stk,
+                             ELOG_TASK_SIZE * sizeof(u32),
+                             ELOG_TASK_PRIO, 0);
+#else
+    ret |= tls_os_sem_create(&elog_lock, 1);
+#endif
+
+    if (TLS_OS_SUCCESS != ret)
+    {
+        result = ELOG_ERR;
+        printf("elog init error\r\n");
+    }
+
+#if (TLS_CONFIG_UDP_SYSLOG == CFG_ON)
+    /* Initialize UDP syslog - may fail if network not ready yet
+     * User can call wm_log_syslog_init() manually after network is up
+     */
+    elog_syslog_init();
+#endif
+
+    return result;
+}
+
+/**
+ * output log port interface
+ *
+ * @param log output of log
+ * @param size log size
+ */
+void elog_port_output(const char *log, size_t size) {
+
+    /* add your code here */
+#if ELOG_USE_TASK_OUTPUT
+    char *msg = tls_mem_alloc(size + 1);
+    if (NULL == msg)
+    {
+        printf("elog malloc error: %.*s", (int)size, log);
+        return;
+    }
+    memcpy(msg, log, size);
+    msg[size] = '\0';
+    int ret = tls_os_queue_send(elog_queue, (void *)msg, 0);
+    if (TLS_OS_SUCCESS != ret)
+    {
+        tls_mem_free(msg);
+        printf("elog send error: %.*s", (int)size, log);
+    }
+#else
+    printf("%.*s", (int)size, log);
+
+#if (TLS_CONFIG_UDP_SYSLOG == CFG_ON)
+    /* WARNING: When ELOG_USE_TASK_OUTPUT is disabled, UDP syslog is sent
+     * directly in caller's context. This may cause deadlock if called from
+     * LwIP TCP/IP callbacks. Enable ELOG_USE_TASK_OUTPUT to avoid this issue.
+     */
+    int severity = elog_parse_severity(log, size);
+    elog_syslog_send(severity, log, size);
+#endif
+#endif
+}
+
+/**
+ * output lock
+ */
+void elog_port_output_lock(void) {
+
+    /* add your code here */
+#if ELOG_USE_TASK_OUTPUT
+    /* don't use lock */
+#else
+    tls_os_sem_acquire(elog_lock, 0);
+#endif
+}
+
+/**
+ * output unlock
+ */
+void elog_port_output_unlock(void) {
+
+    /* add your code here */
+#if ELOG_USE_TASK_OUTPUT
+    /* don't use lock */
+#else
+    tls_os_sem_release(elog_lock);
+#endif
+}
+
+/**
+ * get current time interface
+ *
+ * @return current time
+ */
+const char *elog_port_get_time(void) {
+
+    /* add your code here */
+    static char elog_timestr[16];
+    u32 ticks = tls_os_get_time();
+    sprintf(elog_timestr, "%u.%02u", ticks / HZ, ticks % HZ);
+    return elog_timestr;
+}
+
+/**
+ * get current process name interface
+ *
+ * @return current process name
+ */
+const char *elog_port_get_p_info(void) {
+
+    /* add your code here */
+    return "";
+}
+
+/**
+ * get current thread name interface
+ *
+ * @return current thread name
+ */
+const char *elog_port_get_t_info(void) {
+
+    /* add your code here */
+    const char * pcTaskName;
+    const char * pcNoTask = "Task";
+#if INCLUDE_pcTaskGetTaskName
+    if( xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED )
+    {
+        pcTaskName = (const char *)pcTaskGetTaskName( NULL );
+    }
+    else
+#endif
+    {
+        pcTaskName = pcNoTask;
+    }
+    return pcTaskName;
+}
+
+void wm_log_init(void)
+{
+    /* initialize EasyLogger */
+    elog_init();
+
+    /* set EasyLogger log format */
+    elog_set_fmt(ELOG_LVL_ASSERT, ELOG_FMT_ALL);
+    elog_set_fmt(ELOG_LVL_ERROR, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
+    elog_set_fmt(ELOG_LVL_WARN, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
+    elog_set_fmt(ELOG_LVL_INFO, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
+    elog_set_fmt(ELOG_LVL_DEBUG, ELOG_FMT_ALL & ~ELOG_FMT_FUNC);
+    elog_set_fmt(ELOG_LVL_VERBOSE, ELOG_FMT_ALL & ~ELOG_FMT_FUNC);
+#ifdef ELOG_COLOR_ENABLE
+    elog_set_text_color_enabled(TRUE);
+#endif
+    /* start EasyLogger */
+    elog_start();
+}
+
+#if (TLS_CONFIG_UDP_SYSLOG == CFG_ON)
+/**
+ * Initialize UDP syslog manually
+ * Call this after network is up if automatic initialization failed
+ *
+ * @return 0 on success, -1 on failure
+ */
+int wm_log_syslog_init(void)
+{
+    return elog_syslog_init();
+}
+
+/**
+ * Deinitialize UDP syslog
+ */
+void wm_log_syslog_deinit(void)
+{
+    elog_syslog_deinit();
+}
+
+/**
+ * Check if UDP syslog is initialized and ready
+ *
+ * @return true if initialized, false otherwise
+ */
+bool wm_log_syslog_is_ready(void)
+{
+    return syslog_initialized;
+}
+#endif

MCP_servers/W600-embedded-OBD2/Src/App/easylogger/src/elog.c

@@ -0,0 +1,750 @@
+/*
+ * This file is part of the EasyLogger Library.
+ *
+ * Copyright (c) 2015-2018, Armink, <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Initialize function and other general function.
+ * Created on: 2015-04-28
+ */
+
+#define LOG_TAG      "elog"
+
+#include <elog.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#if !defined(ELOG_OUTPUT_LVL)
+    #error "Please configure static output log level (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_LINE_NUM_MAX_LEN)
+    #error "Please configure output line number max length (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_LINE_BUF_SIZE)
+    #error "Please configure buffer size for every line's log (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_FILTER_TAG_MAX_LEN)
+    #error "Please configure output filter's tag max length (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_FILTER_KW_MAX_LEN)
+    #error "Please configure output filter's keyword max length (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_NEWLINE_SIGN)
+    #error "Please configure output newline sign (in elog_cfg.h)"
+#endif
+
+#ifdef ELOG_COLOR_ENABLE
+/**
+ * CSI(Control Sequence Introducer/Initiator) sign
+ * more information on https://en.wikipedia.org/wiki/ANSI_escape_code
+ */
+#define CSI_START                      "\033["
+#define CSI_END                        "\033[0m"
+/* output log front color */
+#define F_BLACK                        "30;"
+#define F_RED                          "31;"
+#define F_GREEN                        "32;"
+#define F_YELLOW                       "33;"
+#define F_BLUE                         "34;"
+#define F_MAGENTA                      "35;"
+#define F_CYAN                         "36;"
+#define F_WHITE                        "37;"
+/* output log background color */
+#define B_NULL
+#define B_BLACK                        "40;"
+#define B_RED                          "41;"
+#define B_GREEN                        "42;"
+#define B_YELLOW                       "43;"
+#define B_BLUE                         "44;"
+#define B_MAGENTA                      "45;"
+#define B_CYAN                         "46;"
+#define B_WHITE                        "47;"
+/* output log fonts style */
+#define S_BOLD                         "1m"
+#define S_UNDERLINE                    "4m"
+#define S_BLINK                        "5m"
+#define S_NORMAL                       "22m"
+/* output log default color definition: [front color] + [background color] + [show style] */
+#ifndef ELOG_COLOR_ASSERT
+#define ELOG_COLOR_ASSERT              (F_MAGENTA B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_ERROR
+#define ELOG_COLOR_ERROR               (F_RED B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_WARN
+#define ELOG_COLOR_WARN                (F_YELLOW B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_INFO
+#define ELOG_COLOR_INFO                (F_CYAN B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_DEBUG
+#define ELOG_COLOR_DEBUG               (F_GREEN B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_VERBOSE
+#define ELOG_COLOR_VERBOSE             (F_BLUE B_NULL S_NORMAL)
+#endif
+#endif /* ELOG_COLOR_ENABLE */
+
+/* EasyLogger object */
+static EasyLogger elog;
+/* every line log's buffer */
+static char log_buf[ELOG_LINE_BUF_SIZE] = { 0 };
+/* level output info */
+static const char *level_output_info[] = {
+        [ELOG_LVL_ASSERT]  = "WM_A/",
+        [ELOG_LVL_ERROR]   = "WM_E/",
+        [ELOG_LVL_WARN]    = "WM_W/",
+        [ELOG_LVL_INFO]    = "WM_I/",
+        [ELOG_LVL_DEBUG]   = "WM_D/",
+        [ELOG_LVL_VERBOSE] = "WM_V/",
+};
+
+#ifdef ELOG_COLOR_ENABLE
+/* color output info */
+static const char *color_output_info[] = {
+        [ELOG_LVL_ASSERT]  = ELOG_COLOR_ASSERT,
+        [ELOG_LVL_ERROR]   = ELOG_COLOR_ERROR,
+        [ELOG_LVL_WARN]    = ELOG_COLOR_WARN,
+        [ELOG_LVL_INFO]    = ELOG_COLOR_INFO,
+        [ELOG_LVL_DEBUG]   = ELOG_COLOR_DEBUG,
+        [ELOG_LVL_VERBOSE] = ELOG_COLOR_VERBOSE,
+};
+#endif /* ELOG_COLOR_ENABLE */
+
+static bool get_fmt_enabled(uint8_t level, size_t set);
+
+/* EasyLogger assert hook */
+void (*elog_assert_hook)(const char* expr, const char* func, size_t line);
+
+extern void elog_port_output(const char *log, size_t size);
+extern void elog_port_output_lock(void);
+extern void elog_port_output_unlock(void);
+
+/**
+ * EasyLogger initialize.
+ *
+ * @return result
+ */
+ElogErrCode elog_init(void) {
+    extern ElogErrCode elog_port_init(void);
+    extern ElogErrCode elog_async_init(void);
+
+    ElogErrCode result = ELOG_NO_ERR;
+
+    /* port initialize */
+    result = elog_port_init();
+    if (result != ELOG_NO_ERR) {
+        return result;
+    }
+
+#ifdef ELOG_ASYNC_OUTPUT_ENABLE
+    result = elog_async_init();
+    if (result != ELOG_NO_ERR) {
+        return result;
+    }
+#endif
+
+    /* enable the output lock */
+    elog_output_lock_enabled(true);
+    /* output locked status initialize */
+    elog.output_is_locked_before_enable = false;
+    elog.output_is_locked_before_disable = false;
+
+#ifdef ELOG_COLOR_ENABLE
+    /* disable text color by default */
+    elog_set_text_color_enabled(false);
+#endif
+
+    /* set level is ELOG_LVL_VERBOSE */
+    elog_set_filter_lvl(ELOG_LVL_VERBOSE);
+
+    return result;
+}
+
+/**
+ * EasyLogger start after initialize.
+ */
+void elog_start(void) {
+    /* enable output */
+    elog_set_output_enabled(true);
+
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+    elog_async_enabled(true);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+    elog_buf_enabled(true);
+#endif
+
+    /* show version */
+    //log_i("EasyLogger V%s is initialize success.", ELOG_SW_VERSION);
+}
+
+/**
+ * set output enable or disable
+ *
+ * @param enabled TRUE: enable FALSE: disable
+ */
+void elog_set_output_enabled(bool enabled) {
+    ELOG_ASSERT((enabled == false) || (enabled == true));
+
+    elog.output_enabled = enabled;
+}
+
+#ifdef ELOG_COLOR_ENABLE
+/**
+ * set log text color enable or disable
+ * 
+ * @param enabled TRUE: enable FALSE:disable
+ */
+void elog_set_text_color_enabled(bool enabled) {
+    elog.text_color_enabled = enabled;
+}
+
+/**
+ * get log text color enable status
+ *
+ * @return enable or disable
+ */
+bool elog_get_text_color_enabled(void) {
+    return elog.text_color_enabled;
+}
+#endif /* ELOG_COLOR_ENABLE */
+
+/**
+ * get output is enable or disable
+ *
+ * @return enable or disable
+ */
+bool elog_get_output_enabled(void) {
+    return elog.output_enabled;
+}
+
+/**
+ * set log output format. only enable or disable
+ *
+ * @param level level
+ * @param set format set
+ */
+void elog_set_fmt(uint8_t level, size_t set) {
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    elog.enabled_fmt_set[level] = set;
+}
+
+/**
+ * set log filter all parameter
+ *
+ * @param level level
+ * @param tag tag
+ * @param keyword keyword
+ */
+void elog_set_filter(uint8_t level, const char *tag, const char *keyword) {
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    elog_set_filter_lvl(level);
+    elog_set_filter_tag(tag);
+    elog_set_filter_kw(keyword);
+}
+
+/**
+ * set log filter's level
+ *
+ * @param level level
+ */
+void elog_set_filter_lvl(uint8_t level) {
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    elog.filter.level = level;
+}
+
+/**
+ * set log filter's tag
+ *
+ * @param tag tag
+ */
+void elog_set_filter_tag(const char *tag) {
+    strncpy(elog.filter.tag, tag, ELOG_FILTER_TAG_MAX_LEN);
+}
+
+/**
+ * set log filter's keyword
+ *
+ * @param keyword keyword
+ */
+void elog_set_filter_kw(const char *keyword) {
+    strncpy(elog.filter.keyword, keyword, ELOG_FILTER_KW_MAX_LEN);
+}
+
+/**
+ * lock output
+ */
+void elog_output_lock(void) {
+    if (elog.output_lock_enabled) {
+        elog_port_output_lock();
+        elog.output_is_locked_before_disable = true;
+    } else {
+        elog.output_is_locked_before_enable = true;
+    }
+}
+
+/**
+ * unlock output
+ */
+void elog_output_unlock(void) {
+    if (elog.output_lock_enabled) {
+        elog_port_output_unlock();
+        elog.output_is_locked_before_disable = false;
+    } else {
+        elog.output_is_locked_before_enable = false;
+    }
+}
+
+/**
+ * output RAW format log
+ *
+ * @param format output format
+ * @param ... args
+ */
+void elog_raw(const char *format, ...) {
+    va_list args;
+    size_t log_len = 0;
+    int fmt_result;
+
+    /* check output enabled */
+    if (!elog.output_enabled) {
+        return;
+    }
+
+    /* args point to the first variable parameter */
+    va_start(args, format);
+
+    /* lock output */
+    elog_output_lock();
+
+    /* package log data to buffer */
+    fmt_result = vsnprintf(log_buf, ELOG_LINE_BUF_SIZE, format, args);
+
+    /* output converted log */
+    if ((fmt_result > -1) && (fmt_result <= ELOG_LINE_BUF_SIZE)) {
+        log_len = fmt_result;
+    } else {
+        log_len = ELOG_LINE_BUF_SIZE;
+    }
+    /* output log */
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+    extern void elog_async_output(uint8_t level, const char *log, size_t size);
+    /* raw log will using assert level */
+    elog_async_output(ELOG_LVL_ASSERT, log_buf, log_len);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+    extern void elog_buf_output(const char *log, size_t size);
+    elog_buf_output(log_buf, log_len);
+#else
+    elog_port_output(log_buf, log_len);
+#endif
+    /* unlock output */
+    elog_output_unlock();
+
+    va_end(args);
+}
+
+/**
+ * output the log
+ *
+ * @param level level
+ * @param tag tag
+ * @param file file name
+ * @param func function name
+ * @param line line number
+ * @param format output format
+ * @param ... args
+ *
+ */
+void elog_output(uint8_t level, const char *tag, const char *file, const char *func,
+        const long line, const char *format, ...) {
+    extern const char *elog_port_get_time(void);
+    extern const char *elog_port_get_p_info(void);
+    extern const char *elog_port_get_t_info(void);
+
+    size_t tag_len = strlen(tag), log_len = 0, newline_len = strlen(ELOG_NEWLINE_SIGN);
+    char line_num[ELOG_LINE_NUM_MAX_LEN + 1] = { 0 };
+    char tag_sapce[ELOG_FILTER_TAG_MAX_LEN / 2 + 1] = { 0 };
+    va_list args;
+    int fmt_result;
+
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    /* check output enabled */
+    if (!elog.output_enabled) {
+        return;
+    }
+    /* level filter */
+    if (level > elog.filter.level) {
+        return;
+    } else if (!strstr(tag, elog.filter.tag)) { /* tag filter */
+        return;
+    }
+    /* args point to the first variable parameter */
+    va_start(args, format);
+    /* lock output */
+    elog_output_lock();
+
+#ifdef ELOG_COLOR_ENABLE
+    /* add CSI start sign and color info */
+    if (elog.text_color_enabled) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, CSI_START);
+        log_len += elog_strcpy(log_len, log_buf + log_len, color_output_info[level]);
+    }
+#endif
+
+    /* package level info */
+    if (get_fmt_enabled(level, ELOG_FMT_LVL)) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, level_output_info[level]);
+    }
+    /* package tag info */
+    if (get_fmt_enabled(level, ELOG_FMT_TAG)) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, tag);
+        /* if the tag length is less than 50% ELOG_FILTER_TAG_MAX_LEN, then fill space */
+        if (tag_len <= ELOG_FILTER_TAG_MAX_LEN / 2) {
+            memset(tag_sapce, ' ', ELOG_FILTER_TAG_MAX_LEN / 2 - tag_len);
+            log_len += elog_strcpy(log_len, log_buf + log_len, tag_sapce);
+        }
+        log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+    }
+    /* package time, process and thread info */
+    if (get_fmt_enabled(level, ELOG_FMT_TIME | ELOG_FMT_P_INFO | ELOG_FMT_T_INFO)) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, "[");
+        /* package time info */
+        if (get_fmt_enabled(level, ELOG_FMT_TIME)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, elog_port_get_time());
+            if (get_fmt_enabled(level, ELOG_FMT_P_INFO | ELOG_FMT_T_INFO)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            }
+        }
+        /* package process info */
+        if (get_fmt_enabled(level, ELOG_FMT_P_INFO)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, elog_port_get_p_info());
+            if (get_fmt_enabled(level, ELOG_FMT_T_INFO)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            }
+        }
+        /* package thread info */
+        if (get_fmt_enabled(level, ELOG_FMT_T_INFO)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, elog_port_get_t_info());
+        }
+        log_len += elog_strcpy(log_len, log_buf + log_len, "] ");
+    }
+    /* package file directory and name, function name and line number info */
+    if (get_fmt_enabled(level, ELOG_FMT_DIR | ELOG_FMT_FUNC | ELOG_FMT_LINE)) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, "(");
+        /* package time info */
+        if (get_fmt_enabled(level, ELOG_FMT_DIR)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, file);
+            if (get_fmt_enabled(level, ELOG_FMT_FUNC)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            } else if (get_fmt_enabled(level, ELOG_FMT_LINE)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, ":");
+            }
+        }
+        /* package process info */
+        if (get_fmt_enabled(level, ELOG_FMT_FUNC)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, func);
+            if (get_fmt_enabled(level, ELOG_FMT_LINE)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, ":");
+            }
+        }
+        /* package thread info */
+        if (get_fmt_enabled(level, ELOG_FMT_LINE)) {
+            snprintf(line_num, ELOG_LINE_NUM_MAX_LEN, "%ld", line);
+            log_len += elog_strcpy(log_len, log_buf + log_len, line_num);
+        }
+        log_len += elog_strcpy(log_len, log_buf + log_len, ")");
+    }
+    /* package other log data to buffer. '\0' must be added in the end by vsnprintf. */
+    //fmt_result = vsnprintf(log_buf + log_len, ELOG_LINE_BUF_SIZE - log_len, format, args);
+    extern int wm_vsnprintf(char *outstr, size_t size, const char *fmt, va_list arg_ptr);
+    fmt_result = wm_vsnprintf(log_buf + log_len, ELOG_LINE_BUF_SIZE - log_len, format, args);
+
+    va_end(args);
+    /* calculate log length */
+    if ((log_len + fmt_result <= ELOG_LINE_BUF_SIZE) && (fmt_result > -1)) {
+        log_len += fmt_result;
+    } else {
+        /* using max length */
+        log_len = ELOG_LINE_BUF_SIZE;
+    }
+    /* overflow check and reserve some space for CSI end sign and newline sign */
+#ifdef ELOG_COLOR_ENABLE
+    if (log_len + (sizeof(CSI_END) - 1) + newline_len > ELOG_LINE_BUF_SIZE) {
+        /* using max length */
+        log_len = ELOG_LINE_BUF_SIZE;
+        /* reserve some space for CSI end sign */
+        log_len -= (sizeof(CSI_END) - 1);
+#else
+    if (log_len + newline_len > ELOG_LINE_BUF_SIZE) {
+        /* using max length */
+        log_len = ELOG_LINE_BUF_SIZE;
+#endif /* ELOG_COLOR_ENABLE */
+        /* reserve some space for newline sign */
+        log_len -= newline_len;
+    }
+    /* keyword filter */
+    if (elog.filter.keyword[0] != '\0') {
+        /* add string end sign */
+        log_buf[log_len] = '\0';
+        /* find the keyword */
+        if (!strstr(log_buf, elog.filter.keyword)) {
+            /* unlock output */
+            elog_output_unlock();
+            return;
+        }
+    }
+
+#ifdef ELOG_COLOR_ENABLE
+    /* add CSI end sign */
+    if (elog.text_color_enabled) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, CSI_END);
+    }
+#endif
+
+    /* package newline sign */
+    log_len += elog_strcpy(log_len, log_buf + log_len, ELOG_NEWLINE_SIGN);
+    /* output log */
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+    extern void elog_async_output(uint8_t level, const char *log, size_t size);
+    elog_async_output(level, log_buf, log_len);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+    extern void elog_buf_output(const char *log, size_t size);
+    elog_buf_output(log_buf, log_len);
+#else
+    elog_port_output(log_buf, log_len);
+#endif
+    /* unlock output */
+    elog_output_unlock();
+}
+
+/**
+ * get format enabled
+ *
+ * @param level level
+ * @param set format set
+ *
+ * @return enable or disable
+ */
+static bool get_fmt_enabled(uint8_t level, size_t set) {
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    if (elog.enabled_fmt_set[level] & set) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ * enable or disable logger output lock
+ * @note disable this lock is not recommended except you want output system exception log
+ *
+ * @param enabled true: enable  false: disable
+ */
+void elog_output_lock_enabled(bool enabled) {
+    elog.output_lock_enabled = enabled;
+    /* it will re-lock or re-unlock before output lock enable */
+    if (elog.output_lock_enabled) {
+        if (!elog.output_is_locked_before_disable && elog.output_is_locked_before_enable) {
+            /* the output lock is unlocked before disable, and the lock will unlocking after enable */
+            elog_port_output_lock();
+        } else if (elog.output_is_locked_before_disable && !elog.output_is_locked_before_enable) {
+            /* the output lock is locked before disable, and the lock will locking after enable */
+            elog_port_output_unlock();
+        }
+    }
+}
+
+/**
+ * Set a hook function to EasyLogger assert. It will run when the expression is false.
+ *
+ * @param hook the hook function
+ */
+void elog_assert_set_hook(void (*hook)(const char* expr, const char* func, size_t line)) {
+    elog_assert_hook = hook;
+}
+
+/**
+ * find the log level
+ * @note make sure the log level is output on each format
+ *
+ * @param log log buffer
+ *
+ * @return log level, found failed will return -1
+ */
+int8_t elog_find_lvl(const char *log) {
+    ELOG_ASSERT(log);
+    /* make sure the log level is output on each format */
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_ASSERT] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_ERROR] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_WARN] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_INFO] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_DEBUG] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_VERBOSE] & ELOG_FMT_LVL);
+
+#ifdef ELOG_COLOR_ENABLE
+    uint8_t i;
+    size_t csi_start_len = strlen(CSI_START);
+    for(i = 0; i < ELOG_LVL_TOTAL_NUM; i ++) {
+        if (!strncmp(color_output_info[i], log + csi_start_len, strlen(color_output_info[i]))) {
+            return i;
+        }
+    }
+    /* found failed */
+    return -1;
+#else
+    switch (log[0]) {
+    case 'A': return ELOG_LVL_ASSERT;
+    case 'E': return ELOG_LVL_ERROR;
+    case 'W': return ELOG_LVL_WARN;
+    case 'I': return ELOG_LVL_INFO;
+    case 'D': return ELOG_LVL_DEBUG;
+    case 'V': return ELOG_LVL_VERBOSE;
+    default: return -1;
+    }
+#endif
+}
+
+/**
+ * find the log tag
+ * @note make sure the log tag is output on each format
+ * @note the tag don't have space in it
+ *
+ * @param log log buffer
+ * @param lvl log level, you can get it by @see elog_find_lvl
+ * @param tag_len found tag length
+ *
+ * @return log tag, found failed will return NULL
+ */
+const char *elog_find_tag(const char *log, uint8_t lvl, size_t *tag_len) {
+    const char *tag = NULL, *tag_end = NULL;
+
+    ELOG_ASSERT(log);
+    ELOG_ASSERT(tag_len);
+    ELOG_ASSERT(lvl < ELOG_LVL_TOTAL_NUM);
+    /* make sure the log tag is output on each format */
+    ELOG_ASSERT(elog.enabled_fmt_set[lvl] & ELOG_FMT_TAG);
+
+#ifdef ELOG_COLOR_ENABLE
+    tag = log + strlen(CSI_START) + strlen(color_output_info[lvl]) + strlen(level_output_info[lvl]);
+#else
+    tag = log + strlen(level_output_info[lvl]);
+#endif
+    /* find the first space after tag */
+    if ((tag_end = memchr(tag, ' ', ELOG_FILTER_TAG_MAX_LEN)) != NULL) {
+        *tag_len = tag_end - tag;
+    } else {
+        tag = NULL;
+    }
+
+    return tag;
+}
+
+/**
+ * dump the hex format data to log
+ *
+ * @param name name for hex object, it will show on log header
+ * @param width hex number for every line, such as: 16, 32
+ * @param buf hex buffer
+ * @param size buffer size
+ */
+void elog_hexdump(const char *name, uint8_t width, uint8_t *buf, uint16_t size)
+{
+#define __is_print(ch)       ((unsigned int)((ch) - ' ') < 127u - ' ')
+
+    uint16_t i, j;
+    uint16_t log_len = 0;
+    char dump_string[8] = {0};
+    int fmt_result;
+
+    if (!elog.output_enabled) {
+        return;
+    }
+
+    /* level filter */
+    if (ELOG_LVL_DEBUG > elog.filter.level) {
+        return;
+    } else if (!strstr(name, elog.filter.tag)) { /* tag filter */
+        return;
+    }
+ 
+    /* lock output */
+    elog_output_lock();
+
+    for (i = 0; i < size; i += width) {
+        /* package header */
+        fmt_result = snprintf(log_buf, ELOG_LINE_BUF_SIZE, "WM_D/HEX %s: %04X-%04X: ", name, i, i + width);
+        /* calculate log length */
+        if ((fmt_result > -1) && (fmt_result <= ELOG_LINE_BUF_SIZE)) {
+            log_len = fmt_result;
+        } else {
+            log_len = ELOG_LINE_BUF_SIZE;
+        }
+        /* dump hex */
+        for (j = 0; j < width; j++) {
+            if (i + j < size) {
+                snprintf(dump_string, sizeof(dump_string), "%02X ", buf[i + j]);
+            } else {
+                strncpy(dump_string, "   ", sizeof(dump_string));
+            }
+            log_len += elog_strcpy(log_len, log_buf + log_len, dump_string);
+            if ((j + 1) % 8 == 0) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            }
+        }
+        log_len += elog_strcpy(log_len, log_buf + log_len, "  ");
+        /* dump char for hex */
+        for (j = 0; j < width; j++) {
+            if (i + j < size) {
+                snprintf(dump_string, sizeof(dump_string), "%c", __is_print(buf[i + j]) ? buf[i + j] : '.');
+                log_len += elog_strcpy(log_len, log_buf + log_len, dump_string);
+            }
+        }
+        /* overflow check and reserve some space for newline sign */
+        if (log_len + strlen(ELOG_NEWLINE_SIGN) > ELOG_LINE_BUF_SIZE) {
+            log_len = ELOG_LINE_BUF_SIZE - strlen(ELOG_NEWLINE_SIGN);
+        }
+        /* package newline sign */
+        log_len += elog_strcpy(log_len, log_buf + log_len, ELOG_NEWLINE_SIGN);
+        /* do log output */
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+        extern void elog_async_output(uint8_t level, const char *log, size_t size);
+        elog_async_output(ELOG_LVL_DEBUG, log_buf, log_len);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+        extern void elog_buf_output(const char *log, size_t size);
+    elog_buf_output(log_buf, log_len);
+#else
+        elog_port_output(log_buf, log_len);
+#endif
+    }
+    /* unlock output */
+    elog_output_unlock();
+}

MCP_servers/W600-embedded-OBD2/Src/App/easylogger/src/elog_async.c

@@ -0,0 +1,354 @@
+/*
+ * This file is part of the EasyLogger Library.
+ *
+ * Copyright (c) 2016-2017, Armink, <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Logs asynchronous output.
+ * Created on: 2016-11-06
+ */
+
+#include <elog.h>
+#include <string.h>
+
+#ifdef ELOG_ASYNC_OUTPUT_ENABLE
+
+#ifdef ELOG_ASYNC_OUTPUT_USING_PTHREAD
+#include <pthread.h>
+#include <sched.h>
+#include <semaphore.h>
+/* thread default stack size */
+#ifndef ELOG_ASYNC_OUTPUT_PTHREAD_STACK_SIZE
+#if PTHREAD_STACK_MIN > 4*1024
+#define ELOG_ASYNC_OUTPUT_PTHREAD_STACK_SIZE     PTHREAD_STACK_MIN
+#else
+#define ELOG_ASYNC_OUTPUT_PTHREAD_STACK_SIZE     (1*1024)
+#endif
+/* thread default priority */
+#ifndef ELOG_ASYNC_OUTPUT_PTHREAD_PRIORITY
+#define ELOG_ASYNC_OUTPUT_PTHREAD_PRIORITY       (sched_get_priority_max(SCHED_RR) - 1)
+#endif
+/* output thread poll get log buffer size  */
+#ifndef ELOG_ASYNC_POLL_GET_LOG_BUF_SIZE
+#define ELOG_ASYNC_POLL_GET_LOG_BUF_SIZE         (ELOG_LINE_BUF_SIZE - 4)
+#endif
+#endif /* ELOG_ASYNC_OUTPUT_USING_PTHREAD */
+
+/* asynchronous output log notice */
+static sem_t output_notice;
+/* asynchronous output pthread thread */
+static pthread_t async_output_thread;
+#endif /* ELOG_ASYNC_OUTPUT_USING_PTHREAD */
+
+/* the highest output level for async mode, other level will sync output */
+#ifdef ELOG_ASYNC_OUTPUT_LVL
+#define OUTPUT_LVL                               ELOG_ASYNC_OUTPUT_LVL
+#else
+#define OUTPUT_LVL                               ELOG_LVL_ASSERT
+#endif /* ELOG_ASYNC_OUTPUT_LVL */
+
+/* buffer size for asynchronous output mode */
+#ifdef ELOG_ASYNC_OUTPUT_BUF_SIZE
+#define OUTPUT_BUF_SIZE                          ELOG_ASYNC_OUTPUT_BUF_SIZE
+#else
+#define OUTPUT_BUF_SIZE                          (ELOG_LINE_BUF_SIZE * 10)
+#endif /* ELOG_ASYNC_OUTPUT_BUF_SIZE */
+
+/* Initialize OK flag */
+static bool init_ok = false;
+/* asynchronous output mode enabled flag */
+static bool is_enabled = false;
+/* asynchronous output mode's ring buffer */
+static char log_buf[OUTPUT_BUF_SIZE] = { 0 };
+/* log ring buffer write index */
+static size_t write_index = 0;
+/* log ring buffer read index */
+static size_t read_index = 0;
+/* log ring buffer full flag */
+static bool buf_is_full = false;
+/* log ring buffer empty flag */
+static bool buf_is_empty = true;
+
+extern void elog_port_output(const char *log, size_t size);
+extern void elog_output_lock(void);
+extern void elog_output_unlock(void);
+
+/**
+ * asynchronous output ring buffer used size
+ *
+ * @return used size
+ */
+static size_t elog_async_get_buf_used(void) {
+    if (write_index > read_index) {
+        return write_index - read_index;
+    } else {
+        if (!buf_is_full && !buf_is_empty) {
+            return OUTPUT_BUF_SIZE - (read_index - write_index);
+        } else if (buf_is_full) {
+            return OUTPUT_BUF_SIZE;
+        } else {
+            return 0;
+        }
+    }
+}
+
+/**
+ * asynchronous output ring buffer remain space
+ *
+ * @return remain space
+ */
+static size_t async_get_buf_space(void) {
+    return OUTPUT_BUF_SIZE - elog_async_get_buf_used();
+}
+
+/**
+ * put log to asynchronous output ring buffer
+ *
+ * @param log put log buffer
+ * @param size log size
+ *
+ * @return put log size, the log which beyond ring buffer space will be dropped
+ */
+static size_t async_put_log(const char *log, size_t size) {
+    size_t space = 0;
+
+    space = async_get_buf_space();
+    /* no space */
+    if (!space) {
+        size = 0;
+        goto __exit;
+    }
+    /* drop some log */
+    if (space <= size) {
+        size = space;
+        buf_is_full = true;
+    }
+
+    if (write_index + size < OUTPUT_BUF_SIZE) {
+        memcpy(log_buf + write_index, log, size);
+        write_index += size;
+    } else {
+        memcpy(log_buf + write_index, log, OUTPUT_BUF_SIZE - write_index);
+        memcpy(log_buf, log + OUTPUT_BUF_SIZE - write_index,
+                size - (OUTPUT_BUF_SIZE - write_index));
+        write_index += size - OUTPUT_BUF_SIZE;
+    }
+
+    buf_is_empty = false;
+
+__exit:
+
+    return size;
+}
+
+#ifdef ELOG_ASYNC_LINE_OUTPUT
+/**
+ * Get line log from asynchronous output ring buffer.
+ * It will copy all log when the newline sign isn't find.
+ *
+ * @param log get line log buffer
+ * @param size line log size
+ *
+ * @return get line log size, the log size is less than ring buffer used size
+ */
+size_t elog_async_get_line_log(char *log, size_t size) {
+    size_t used = 0, cpy_log_size = 0;
+    /* lock output */
+    elog_output_lock();
+    used = elog_async_get_buf_used();
+
+    /* no log */
+    if (!used || !size) {
+        goto __exit;
+    }
+    /* less log */
+    if (used <= size) {
+        size = used;
+    }
+
+    if (read_index + size < OUTPUT_BUF_SIZE) {
+        cpy_log_size = elog_cpyln(log, log_buf + read_index, size);
+        read_index += cpy_log_size;
+    } else {
+        cpy_log_size = elog_cpyln(log, log_buf + read_index, OUTPUT_BUF_SIZE - read_index);
+        if (cpy_log_size == OUTPUT_BUF_SIZE - read_index) {
+            cpy_log_size += elog_cpyln(log + cpy_log_size, log_buf, size - cpy_log_size);
+            read_index += cpy_log_size - OUTPUT_BUF_SIZE;
+        } else {
+            read_index += cpy_log_size;
+        }
+    }
+
+    if (used == cpy_log_size) {
+        buf_is_empty = true;
+    }
+
+    if (cpy_log_size) {
+        buf_is_full = false;
+    }
+
+__exit:
+    /* lock output */
+    elog_output_unlock();
+    return cpy_log_size;
+}
+#else
+/**
+ * get log from asynchronous output ring buffer
+ *
+ * @param log get log buffer
+ * @param size log size
+ *
+ * @return get log size, the log size is less than ring buffer used size
+ */
+size_t elog_async_get_log(char *log, size_t size) {
+    size_t used = 0;
+    /* lock output */
+    elog_output_lock();
+    used = elog_async_get_buf_used();
+    /* no log */
+    if (!used || !size) {
+        size = 0;
+        goto __exit;
+    }
+    /* less log */
+    if (used <= size) {
+        size = used;
+        buf_is_empty = true;
+    }
+
+    if (read_index + size < OUTPUT_BUF_SIZE) {
+        memcpy(log, log_buf + read_index, size);
+        read_index += size;
+    } else {
+        memcpy(log, log_buf + read_index, OUTPUT_BUF_SIZE - read_index);
+        memcpy(log + OUTPUT_BUF_SIZE - read_index, log_buf,
+                size - (OUTPUT_BUF_SIZE - read_index));
+        read_index += size - OUTPUT_BUF_SIZE;
+    }
+
+    buf_is_full = false;
+
+__exit:
+    /* lock output */
+    elog_output_unlock();
+    return size;
+}
+#endif /* ELOG_ASYNC_LINE_OUTPUT */
+
+void elog_async_output(uint8_t level, const char *log, size_t size) {
+    /* this function must be implement by user when ELOG_ASYNC_OUTPUT_USING_PTHREAD is not defined */
+    extern void elog_async_output_notice(void);
+    size_t put_size;
+
+    if (is_enabled) {
+        if (level >= OUTPUT_LVL) {
+            put_size = async_put_log(log, size);
+            /* notify output log thread */
+            if (put_size > 0) {
+                elog_async_output_notice();
+            }
+        } else {
+            elog_port_output(log, size);
+        }
+    } else {
+        elog_port_output(log, size);
+    }
+}
+
+#ifdef ELOG_ASYNC_OUTPUT_USING_PTHREAD
+void elog_async_output_notice(void) {
+    sem_post(&output_notice);
+}
+
+static void *async_output(void *arg) {
+    size_t get_log_size = 0;
+    static char poll_get_buf[ELOG_ASYNC_POLL_GET_LOG_BUF_SIZE];
+
+    ELOG_ASSERT(init_ok);
+
+    while(true) {
+        /* waiting log */
+        sem_wait(&output_notice);
+        /* polling gets and outputs the log */
+        while(true) {
+
+#ifdef ELOG_ASYNC_LINE_OUTPUT
+            get_log_size = elog_async_get_line_log(poll_get_buf, ELOG_ASYNC_POLL_GET_LOG_BUF_SIZE);
+#else
+            get_log_size = elog_async_get_log(poll_get_buf, ELOG_ASYNC_POLL_GET_LOG_BUF_SIZE);
+#endif
+
+            if (get_log_size) {
+                elog_port_output(poll_get_buf, get_log_size);
+            } else {
+                break;
+            }
+        }
+    }
+    return NULL;
+}
+#endif
+
+/**
+ * enable or disable asynchronous output mode
+ * the log will be output directly when mode is disabled
+ *
+ * @param enabled true: enabled, false: disabled
+ */
+void elog_async_enabled(bool enabled) {
+    is_enabled = enabled;
+}
+
+/**
+ * asynchronous output mode initialize
+ *
+ * @return result
+ */
+ElogErrCode elog_async_init(void) {
+    ElogErrCode result = ELOG_NO_ERR;
+
+    if (init_ok) {
+        return result;
+    }
+
+#ifdef ELOG_ASYNC_OUTPUT_USING_PTHREAD
+    pthread_attr_t thread_attr;
+    struct sched_param thread_sched_param;
+
+    sem_init(&output_notice, 0, 0);
+
+    pthread_attr_init(&thread_attr);
+    pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
+    pthread_attr_setstacksize(&thread_attr, ELOG_ASYNC_OUTPUT_PTHREAD_STACK_SIZE);
+    pthread_attr_setschedpolicy(&thread_attr, SCHED_RR);
+    thread_sched_param.sched_priority = ELOG_ASYNC_OUTPUT_PTHREAD_PRIORITY;
+    pthread_attr_setschedparam(&thread_attr, &thread_sched_param);
+    pthread_create(&async_output_thread, &thread_attr, async_output, NULL);
+    pthread_attr_destroy(&thread_attr);
+#endif
+
+    init_ok = true;
+
+    return result;
+}
+
+#endif /* ELOG_ASYNC_OUTPUT_ENABLE */

MCP_servers/W600-embedded-OBD2/Src/App/easylogger/src/elog_buf.c

@@ -0,0 +1,104 @@
+/*
+ * This file is part of the EasyLogger Library.
+ *
+ * Copyright (c) 2016, Armink, <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Logs buffered output.
+ * Created on: 2016-11-09
+ */
+
+#include <elog.h>
+#include <string.h>
+
+#ifdef ELOG_BUF_OUTPUT_ENABLE
+#if !defined(ELOG_BUF_OUTPUT_BUF_SIZE)
+    #error "Please configure buffer size for buffered output mode (in elog_cfg.h)"
+#endif
+
+/* buffered output mode's buffer */
+static char log_buf[ELOG_BUF_OUTPUT_BUF_SIZE] = { 0 };
+/* log buffer current write size */
+static size_t buf_write_size = 0;
+/* buffered output mode enabled flag */
+static bool is_enabled = false;
+
+extern void elog_port_output(const char *log, size_t size);
+extern void elog_output_lock(void);
+extern void elog_output_unlock(void);
+
+/**
+ * output buffered logs when buffer is full
+ *
+ * @param log will be buffered line's log
+ * @param size log size
+ */
+void elog_buf_output(const char *log, size_t size) {
+    size_t write_size = 0, write_index = 0;
+
+    if (!is_enabled) {
+        elog_port_output(log, size);
+        return;
+    }
+
+    while (true) {
+        if (buf_write_size + size > ELOG_BUF_OUTPUT_BUF_SIZE) {
+            write_size = ELOG_BUF_OUTPUT_BUF_SIZE - buf_write_size;
+            memcpy(log_buf + buf_write_size, log + write_index, write_size);
+            write_index += write_size;
+            size -= write_size;
+            buf_write_size += write_size;
+            /* output log */
+            elog_port_output(log_buf, buf_write_size);
+            /* reset write index */
+            buf_write_size = 0;
+        } else {
+            memcpy(log_buf + buf_write_size, log + write_index, size);
+            buf_write_size += size;
+            break;
+        }
+    }
+}
+
+/**
+ * flush all buffered logs to output device
+ */
+void elog_flush(void) {
+    /* lock output */
+    elog_output_lock();
+    /* output log */
+    elog_port_output(log_buf, buf_write_size);
+    /* reset write index */
+    buf_write_size = 0;
+    /* unlock output */
+    elog_output_unlock();
+}
+
+/**
+ * enable or disable buffered output mode
+ * the log will be output directly when mode is disabled
+ *
+ * @param enabled true: enabled, false: disabled
+ */
+void elog_buf_enabled(bool enabled) {
+    is_enabled = enabled;
+}
+#endif /* ELOG_BUF_OUTPUT_ENABLE */

MCP_servers/W600-embedded-OBD2/Src/App/easylogger/src/elog_utils.c

@@ -0,0 +1,103 @@
+/*
+ * This file is part of the EasyLogger Library.
+ *
+ * Copyright (c) 2015-2018, Armink, <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Some utils for this library.
+ * Created on: 2015-04-28
+ */
+
+#include <elog.h>
+#include <string.h>
+
+/**
+ * another copy string function
+ *
+ * @param cur_len current copied log length, max size is ELOG_LINE_BUF_SIZE
+ * @param dst destination
+ * @param src source
+ *
+ * @return copied length
+ */
+size_t elog_strcpy(size_t cur_len, char *dst, const char *src) {
+    const char *src_old = src;
+
+    assert(dst);
+    assert(src);
+
+    while (*src != 0) {
+        /* make sure destination has enough space */
+        if (cur_len++ < ELOG_LINE_BUF_SIZE) {
+            *dst++ = *src++;
+        } else {
+            break;
+        }
+    }
+    return src - src_old;
+}
+
+/**
+ * Copy line log split by newline sign. It will copy all log when the newline sign isn't find.
+ *
+ * @param line line log buffer
+ * @param log origin log buffer
+ * @param len origin log buffer length
+ *
+ * @return copy size
+ */
+size_t elog_cpyln(char *line, const char *log, size_t len) {
+    size_t newline_len = strlen(ELOG_NEWLINE_SIGN), copy_size = 0;
+
+    assert(line);
+    assert(log);
+
+    while (len--) {
+        *line++ = *log++;
+        copy_size++;
+        if (copy_size >= newline_len && !strncmp(log - newline_len, ELOG_NEWLINE_SIGN, newline_len)) {
+            break;
+        }
+    }
+    return copy_size;
+}
+
+/**
+ * This function will copy memory content from source address to destination
+ * address.
+ *
+ * @param dst the address of destination memory
+ * @param src  the address of source memory
+ * @param count the copied length
+ *
+ * @return the address of destination memory
+ */
+void *elog_memcpy(void *dst, const void *src, size_t count) {
+    char *tmp = (char *) dst, *s = (char *) src;
+
+    assert(dst);
+    assert(src);
+
+    while (count--)
+        *tmp++ = *s++;
+
+    return dst;
+}

MCP_servers/W600-embedded-OBD2/Src/App/elm327/Makefile

@@ -0,0 +1,44 @@
+#*****************************************************************************
+# ELM327 OBD-II Interface Library Makefile
+#*****************************************************************************
+
+ifeq ($(COMPILER_OS_CYGWIN),1)
+TOPDIR=../../..
+endif
+
+include $(TOPDIR)/Tools/toolchain.def
+
+#*****************************************************************************
+# Target definition
+#*****************************************************************************
+GOAL  = $(LIB_DIR)/wmelm327.$(LIBTYPE)
+
+#*****************************************************************************
+# Source section
+#*****************************************************************************
+ASM_SRC +=
+C_SRC += elm327.c elm327_sim.c elm327_history.c
+
+#*****************************************************************************
+# Implicit rules
+#*****************************************************************************
+.c.o:
+	$(CC) $(CFLAGS) -c -o $*.o $< $(INCLUDES)
+
+.s.o:
+	$(ASM) $(ASMFLAGS) -c -o $*.o $< $(INCLUDES)
+
+#*****************************************************************************
+# Explicit rules
+#*****************************************************************************
+OBJ_FILES = $(C_SRC:%.c=%.o) $(ASM_SRC:%.s=%.o)
+
+all: $(GOAL)
+
+$(GOAL): $(OBJ_FILES)
+	$(AR) $(ARFLAGS) $@ $(OBJ_FILES)
+
+.PHONY: clean
+clean:
+	$(RM) -f $(GOAL)
+	$(RM) -f $(OBJ_FILES:.o=.d) $(OBJ_FILES)

MCP_servers/W600-embedded-OBD2/Src/App/elm327/README_SIMULATION.md

@@ -0,0 +1,313 @@
+# ELM327 OBD-II Simulator
+
+## Overview
+
+The ELM327 simulator provides simulated OBD-II responses for testing without a vehicle connection. This allows development and testing when the ELM327 is powered on but not connected to a vehicle's OBD-II port.
+
+## Key Features
+
+- **AT Commands**: Always passed through to real ELM327 hardware
+- **OBD-II Commands**: Simulated responses when not connected to vehicle
+- **Dynamic Values**: Realistic time-varying data for RPM, speed, temperature
+- **Easy Toggle**: Enable/disable simulation at runtime or compile time
+
+## Architecture
+
+```
+┌─────────────────────────────────────────┐
+│   MCP Tool / Application Layer          │
+│   (transparent - no changes needed)     │
+└──────────────────┬──────────────────────┘
+                   │
+                   ↓
+┌─────────────────────────────────────────┐
+│   ELM327 Driver (elm327.c)              │
+│   elm327_send_command()                 │
+│                                         │
+│   ┌─────────────────────────────────┐  │
+│   │ Command Classifier               │  │
+│   │ - AT command? → Real hardware    │  │
+│   │ - OBD-II? → Simulator            │  │
+│   └─────────────────────────────────┘  │
+│                                         │
+│   ┌──────────────┐  ┌─────────────┐   │
+│   │ UART/HW      │  │ Simulator   │   │
+│   │ (elm327.c)   │  │ (elm327_sim)│   │
+│   └──────────────┘  └─────────────┘   │
+└─────────────────────────────────────────┘
+```
+
+## Configuration
+
+### Compile-Time Configuration
+
+Edit `Include/wm_config.h`:
+
+```c
+/** ELM327 OBD-II **/
+#define TLS_CONFIG_ELM327_SIMULATION    CFG_ON   // Enable simulator
+// or
+#define TLS_CONFIG_ELM327_SIMULATION    CFG_OFF  // Disable (production)
+```
+
+When `CFG_OFF`, simulation code is completely excluded from the build.
+
+### Runtime Control
+
+When compiled with simulation support, you can control it at runtime:
+
+```c
+#include "elm327.h"
+
+// Enable simulation
+elm327_set_simulation_mode(true);
+
+// Disable simulation (use real hardware)
+elm327_set_simulation_mode(false);
+
+// Check status
+if (elm327_is_simulation_enabled()) {
+    // Currently simulating
+}
+```
+
+## Supported PIDs
+
+The simulator supports multiple OBD-II modes:
+
+### Mode 01: Show Current Data
+
+#### Static PIDs
+- `01 00` - Supported PIDs 01-20
+- `01 01` - Monitor status since DTCs cleared
+- `01 03` - Fuel system status
+- `01 06` - Short term fuel trim
+- `01 07` - Long term fuel trim
+- `01 0A` - Fuel pressure
+- `01 0B` - Intake manifold pressure
+- `01 0E` - Timing advance
+- `01 0F` - Intake air temperature
+- `01 13` - O2 sensors present
+- `01 1C` - OBD standard
+- `01 1F` - Run time since engine start
+- `01 20` - Supported PIDs 21-40
+- `01 21` - Distance with MIL on
+- `01 33` - Barometric pressure
+- `01 40` - Supported PIDs 41-60
+- `01 42` - Control module voltage
+- `01 51` - Fuel type
+
+#### Dynamic PIDs (Time-Varying)
+- `01 04` - Calculated engine load
+- `01 05` - Engine coolant temperature
+- `01 0C` - Engine RPM
+- `01 0D` - Vehicle speed
+- `01 10` - MAF air flow rate
+- `01 11` - Throttle position
+- `01 2F` - Fuel tank level
+
+### Mode 03: Show Stored DTCs
+
+- `03` - Request stored Diagnostic Trouble Codes
+  - Returns 3 simulated DTCs:
+    - `P0171` - System Too Lean (Bank 1)
+    - `P0300` - Random/Multiple Cylinder Misfire Detected
+    - `P0442` - EVAP System Leak Detected (small leak)
+
+### Mode 04: Clear DTCs
+
+- `04` - Clear Diagnostic Trouble Codes
+  - Acknowledges clear command (DTCs remain in simulator for testing)
+
+### Mode 07: Show Pending DTCs
+
+- `07` - Request pending Diagnostic Trouble Codes
+  - Returns 1 pending DTC:
+    - `P0131` - O2 Sensor Circuit Low Voltage (Bank 1, Sensor 1)
+
+### Mode 09: Request Vehicle Information
+
+- `09 00` - Supported PIDs (returns available vehicle info PIDs)
+- `09 02` - **Vehicle Identification Number (VIN)**
+  - Returns: `1HGBH41JXMN109186` (Honda Accord example)
+  - Format: 17 ASCII characters encoded as hex bytes
+- `09 04` - **Calibration ID**
+  - Returns: `CAL123456`
+  - Identifies the ECU calibration version
+- `09 0A` - **ECU Name**
+  - Returns: `ECU_SIM_UNIT`
+  - Human-readable ECU identification
+
+## Usage Examples
+
+### Basic Usage
+
+```c
+#include "elm327.h"
+
+void test_elm327(void)
+{
+    char response[ELM327_MAX_RESPONSE_LEN];
+    int ret;
+
+    // Initialize ELM327 (simulation enabled by default if compiled in)
+    elm327_init();
+
+    // AT commands go to real hardware
+    ret = elm327_send_command("ATZ", response, sizeof(response), 2000);
+    // Real ELM327 will respond with version info
+
+    // OBD-II commands are simulated
+    ret = elm327_send_command("01 0C", response, sizeof(response), 2000);
+    // Response: "41 0C 0F A0" (RPM data)
+}
+```
+
+### Controlling Engine State
+
+```c
+// Start engine (affects RPM, temperature, etc.)
+elm327_set_engine_state(true);
+
+// Query RPM - will show idle RPM (~800)
+elm327_send_command("01 0C", response, sizeof(response), 2000);
+
+// Stop engine
+elm327_set_engine_state(false);
+
+// Query RPM - will show 0
+elm327_send_command("01 0C", response, sizeof(response), 2000);
+```
+
+### Querying Vehicle Information
+
+```c
+#include "elm327.h"
+
+void get_vehicle_info(void)
+{
+    char response[ELM327_MAX_RESPONSE_LEN];
+    int ret;
+
+    // Get VIN
+    ret = elm327_send_command("09 02", response, sizeof(response), 2000);
+    // Response: "49 02 01 31 48 47 42 48 34 31 4A 58 4D 4E 31 30 39 31 38 36"
+    // Decodes to: "1HGBH41JXMN109186"
+
+    // Get Calibration ID
+    ret = elm327_send_command("09 04", response, sizeof(response), 2000);
+    // Response: "49 04 01 43 41 4C 31 32 33 34 35 36"
+    // Decodes to: "CAL123456"
+
+    // Get ECU Name
+    ret = elm327_send_command("09 0A", response, sizeof(response), 2000);
+    // Response: "49 0A 01 45 43 55 5F 53 49 4D 5F 55 4E 49 54"
+    // Decodes to: "ECU_SIM_UNIT"
+}
+```
+
+### Testing MCP Integration
+
+```bash
+# With MCP server running and simulation enabled:
+
+# AT command - goes to real ELM327
+curl http://192.168.10.1/mcp -d '{"method":"diag/send_elm327_command","params":{"command":"ATZ"}}'
+
+# OBD-II command - simulated response
+curl http://192.168.10.1/mcp -d '{"method":"diag/send_elm327_command","params":{"command":"01 0C"}}'
+
+# Get VIN - simulated response
+curl http://192.168.10.1/mcp -d '{"method":"diag/send_elm327_command","params":{"command":"09 02"}}'
+```
+
+## Vehicle State Simulation
+
+The simulator maintains internal state for realistic dynamic responses:
+
+- **Engine Running**: Affects all dynamic PIDs
+- **RPM**: Varies slightly at idle, increases with throttle
+- **Coolant Temperature**: Gradually increases when engine running
+- **Speed**: Varies based on throttle position
+- **Throttle Position**: Simulated variations over time
+- **MAF Rate**: Follows throttle position
+- **Fuel Level**: Static (can be modified)
+
+State updates happen automatically in `elm327_sim_update_state()` (called internally).
+
+## Implementation Files
+
+```
+Src/App/elm327/
+├── elm327.c              # Main driver with simulation integration
+├── elm327_sim.c          # Simulation engine and data tables
+├── elm327_sim.h          # Internal simulator API
+├── Makefile              # Conditional compilation
+└── README_SIMULATION.md  # This file
+
+Include/App/
+└── elm327.h              # Public API with simulation functions
+```
+
+## Adding New PIDs
+
+To add support for additional PIDs, edit `elm327_sim.c`:
+
+1. Add entry to `mode01_pid_table[]`:
+
+```c
+{"XX", "41 XX [data]", false},  // Static response
+// or
+{"XX", NULL, true},              // Dynamic response
+```
+
+2. For dynamic PIDs, add generator function:
+
+```c
+static int generate_custom_pid_response(char *response, int max_len)
+{
+    uint8_t value = /* calculate value */;
+    return snprintf(response, max_len, "41 XX %02X", value);
+}
+```
+
+3. Add case in `elm327_sim_generate_response()`:
+
+```c
+} else if (strcmp(pid, "XX") == 0) {
+    len = generate_custom_pid_response(response, max_len);
+```
+
+## Disabling for Production
+
+For production builds without simulation overhead:
+
+1. Edit `Include/wm_config.h`:
+   ```c
+   #define TLS_CONFIG_ELM327_SIMULATION    CFG_OFF
+   ```
+
+2. Rebuild:
+   ```bash
+   cd Tools/GNU
+   make clean
+   make
+   ```
+
+The simulator code will be completely excluded from the binary.
+
+## Logging
+
+When simulation is active, log messages indicate simulated responses:
+
+```
+[ELM327/SIM] ELM327 Req (SIM): 01 0C
+[ELM327/SIM] ELM327 Res (SIM): 41 0C 0F A0
+```
+
+Real hardware responses are logged without "(SIM)" marker:
+
+```
+[ELM327] ELM327 Req: ATZ
+[ELM327] ELM327 Res: ELM327 v2.1
+```

MCP_servers/W600-embedded-OBD2/Src/App/elm327/elm327.c

@@ -0,0 +1,312 @@
+/**
+ * @file    elm327.c
+ *
+ * @brief   ELM327 OBD-II Interface Implementation
+ * 
+ * @author  castlebbs
+ *
+ */
+
+#define LOG_TAG "ELM327/Driver"
+
+#include "elm327.h"
+#include "wm_uart.h"
+#include "wm_osal.h"
+#include "wm_log.h"
+#include <string.h>
+#include <stdio.h>
+
+#if (TLS_CONFIG_ELM327_SIMULATION == CFG_ON)
+#include "elm327_sim.h"
+#endif
+
+// Internal state
+static struct {
+    bool initialized;
+    tls_os_mutex_t *cmd_mutex;     // Serializes concurrent access to ELM327
+    tls_os_sem_t *response_sem;    // Signals when response complete
+    char rx_buffer[ELM327_MAX_RESPONSE_LEN];
+    int rx_len;
+    bool response_ready;
+#if (TLS_CONFIG_ELM327_SIMULATION == CFG_ON)
+    bool simulation_enabled;       // Enable simulation mode
+#endif
+} elm327_ctx = {0};
+
+/**
+ * @brief Check if command is an AT command (should go to real hardware)
+ */
+static bool is_at_command(const char *cmd)
+{
+    if (!cmd || strlen(cmd) < 2)
+        return false;
+
+    // Check if command starts with "AT" (case insensitive)
+    return (cmd[0] == 'A' || cmd[0] == 'a') &&
+           (cmd[1] == 'T' || cmd[1] == 't');
+}
+
+/**
+ * @brief RX callback - called from interrupt context when data arrives
+ */
+static s16 elm327_rx_callback(u16 len)
+{
+    int available;
+    char ch;
+
+    // Read available data
+    while (len > 0) {
+        // Read one byte at a time to check for prompt
+        available = tls_uart_read(TLS_UART_1, (u8*)&ch, 1);
+        if (available <= 0)
+            break;
+
+        len--;
+
+        // Check for ELM327 prompt '>' which signals end of response
+        if (ch == '>') {
+            elm327_ctx.rx_buffer[elm327_ctx.rx_len] = '\0';
+            elm327_ctx.response_ready = true;
+
+            // Signal waiting thread
+            if (elm327_ctx.response_sem) {
+                tls_os_sem_release(elm327_ctx.response_sem);
+            }
+            break;
+        }
+
+        // Filter out carriage returns for cleaner output
+        if (ch == '\r') {
+            continue;
+        }
+
+        // Buffer overflow protection
+        if (elm327_ctx.rx_len >= ELM327_MAX_RESPONSE_LEN - 1) {
+            // Overflow - discard and reset
+            elm327_ctx.rx_len = 0;
+            continue;
+        }
+
+        // Append to buffer
+        elm327_ctx.rx_buffer[elm327_ctx.rx_len++] = ch;
+    }
+
+    return WM_SUCCESS;
+}
+
+int elm327_init(void)
+{
+    wm_log_info("Initializing ELM327...");
+    tls_uart_options_t uart_opts;
+    int ret;
+
+    if (elm327_ctx.initialized) {
+        wm_log_info("ELM327 already initialized");
+        return WM_SUCCESS;  // Already initialized
+    }
+
+    memset(&elm327_ctx, 0, sizeof(elm327_ctx));
+
+    // Configure UART1: 38400 8N1
+    uart_opts.baudrate = 38400;
+    uart_opts.charlength = TLS_UART_CHSIZE_8BIT;
+    uart_opts.paritytype = TLS_UART_PMODE_DISABLED;
+    uart_opts.stopbits = TLS_UART_ONE_STOPBITS;
+    uart_opts.flow_ctrl = TLS_UART_FLOW_CTRL_NONE;
+
+    // Initialize UART port
+    ret = tls_uart_port_init(TLS_UART_1, &uart_opts, 0);
+    if (ret != WM_SUCCESS) {
+        wm_log_error("UART init failed");
+        return ret;
+    }
+
+    // Create mutex for serializing concurrent access
+    ret = tls_os_mutex_create(0, &elm327_ctx.cmd_mutex);
+    if (ret != TLS_OS_SUCCESS) {
+        wm_log_error("Mutex creation failed");
+        return WM_FAILED;
+    }
+
+    // Create semaphore for response synchronization
+    ret = tls_os_sem_create(&elm327_ctx.response_sem, 0);
+    if (ret != TLS_OS_SUCCESS) {
+        wm_log_error("Semaphore creation failed");
+        tls_os_mutex_delete(elm327_ctx.cmd_mutex);
+        return WM_FAILED;
+    }
+
+    // Register RX callback
+    tls_uart_rx_callback_register(TLS_UART_1, elm327_rx_callback);
+
+#if (TLS_CONFIG_ELM327_SIMULATION == CFG_ON)
+    // Initialize simulator (enabled by default in simulation build)
+    elm327_ctx.simulation_enabled = true;
+    elm327_sim_init();
+    wm_log_info("Simulation mode enabled");
+#endif
+
+    elm327_ctx.initialized = true;
+
+    wm_log_info("Initialized on UART1 @ 38400 baud");
+    return WM_SUCCESS;
+}
+
+int elm327_send_command(const char *cmd, char *response,
+                        int max_len, u32 timeout_ms)
+{
+    int cmd_len;
+    int ret;
+    u8 err;
+
+    if (!elm327_ctx.initialized) {
+        return -1;  // Not initialized
+    }
+
+    if (!cmd || !response || max_len <= 0) {
+        return -2;  // Invalid parameters
+    }
+
+#if (TLS_CONFIG_ELM327_SIMULATION == CFG_ON)
+    // Check if we should simulate this command
+    if (elm327_ctx.simulation_enabled && !is_at_command(cmd)) {
+        // Simulate OBD-II response (non-AT commands)
+        wm_log_info("Req (SIM): %s", cmd);
+
+        // Update vehicle state for dynamic simulation
+        elm327_sim_update_state();
+
+        ret = elm327_sim_generate_response(cmd, response, max_len);
+
+        if (ret > 0) {
+            wm_log_info("Res (SIM): %s", response);
+        } else {
+            wm_log_info("Res (SIM): (empty/error)");
+        }
+
+        return ret;
+    }
+    // AT commands or simulation disabled - fall through to real hardware
+#endif
+
+    // Acquire mutex to serialize access to ELM327
+    // This ensures only one command is in-flight at a time
+    tls_os_mutex_acquire(elm327_ctx.cmd_mutex, 0);
+
+    // Reset RX state
+    elm327_ctx.rx_len = 0;
+    elm327_ctx.response_ready = false;
+    memset(elm327_ctx.rx_buffer, 0, sizeof(elm327_ctx.rx_buffer));
+
+    // Flush any pending RX data
+    tls_uart_read(TLS_UART_1, (u8*)elm327_ctx.rx_buffer,
+                  ELM327_MAX_RESPONSE_LEN);
+    elm327_ctx.rx_len = 0;
+
+    // Send command (ELM327 expects \r terminator)
+    cmd_len = strlen(cmd);
+
+    // Log the command being sent
+    wm_log_info("Req: %s", cmd);
+
+    ret = tls_uart_write(TLS_UART_1, (char*)cmd, cmd_len);
+    if (ret != WM_SUCCESS) {
+        wm_log_error("Send failed");
+        tls_os_mutex_release(elm327_ctx.cmd_mutex);
+        return -3;
+    }
+
+    // Send carriage return if not already present
+    if (cmd[cmd_len - 1] != '\r') {
+        tls_uart_write(TLS_UART_1, "\r", 1);
+    }
+
+    // Wait for response with timeout
+    err = tls_os_sem_acquire(elm327_ctx.response_sem, timeout_ms);
+    if (err != TLS_OS_SUCCESS) {
+        wm_log_error("Timeout waiting for response\n");
+        tls_os_mutex_release(elm327_ctx.cmd_mutex);
+        return -4;  // Timeout
+    }
+
+    // Copy response to user buffer
+    if (elm327_ctx.rx_len > 0) {
+        char *src = elm327_ctx.rx_buffer;
+        int src_len = elm327_ctx.rx_len;
+
+        // Remove echoed command if present at beginning (ECHO ON case)
+        // Compare against command without trailing \r
+        int cmd_cmp_len = cmd_len;
+        if (cmd_cmp_len > 0 && cmd[cmd_cmp_len - 1] == '\r') {
+            cmd_cmp_len--;
+        }
+
+        // Check if response starts with the command
+        if (src_len >= cmd_cmp_len &&
+            memcmp(src, cmd, cmd_cmp_len) == 0) {
+            // Skip past the echoed command
+            src += cmd_cmp_len;
+            src_len -= cmd_cmp_len;
+        }
+
+        // Copy remaining response to user buffer
+        if (src_len > 0) {
+            int copy_len = (src_len < max_len) ? src_len : max_len - 1;
+            memcpy(response, src, copy_len);
+            response[copy_len] = '\0';
+
+            // Log the response received
+            wm_log_info("Res: %s", response);
+
+            tls_os_mutex_release(elm327_ctx.cmd_mutex);
+            return copy_len;
+        }
+    }
+
+    // Log empty response
+    wm_log_info("Res: (empty)");
+
+    tls_os_mutex_release(elm327_ctx.cmd_mutex);
+    return 0;  // Empty response
+}
+
+void elm327_deinit(void)
+{
+    if (!elm327_ctx.initialized)
+        return;
+
+    // Unregister callback
+    tls_uart_rx_callback_register(TLS_UART_1, NULL);
+
+    // Delete mutex
+    if (elm327_ctx.cmd_mutex) {
+        tls_os_mutex_delete(elm327_ctx.cmd_mutex);
+        elm327_ctx.cmd_mutex = NULL;
+    }
+
+    // Delete semaphore
+    if (elm327_ctx.response_sem) {
+        tls_os_sem_delete(elm327_ctx.response_sem);
+        elm327_ctx.response_sem = NULL;
+    }
+
+    elm327_ctx.initialized = false;
+}
+
+#if (TLS_CONFIG_ELM327_SIMULATION == CFG_ON)
+void elm327_set_simulation_mode(bool enable)
+{
+    elm327_ctx.simulation_enabled = enable;
+    wm_log_info("Simulation mode %s", enable ? "enabled" : "disabled");
+}
+
+bool elm327_is_simulation_enabled(void)
+{
+    return elm327_ctx.simulation_enabled;
+}
+
+void elm327_set_engine_state(bool running)
+{
+    elm327_sim_set_engine_state(running);
+}
+#endif

MCP_servers/W600-embedded-OBD2/Src/App/elm327/elm327_history.c

@@ -0,0 +1,275 @@
+/**
+ * @file    elm327_history.c
+ *
+ * @brief   ELM327 OBD-II Data History Implementation
+ * 
+ * @author  castlebbs
+ * 
+ */
+
+#define LOG_TAG "ELM327/History"
+
+#include "elm327_history.h"
+#include "elm327.h"
+#include "wm_osal.h"
+#include "wm_log.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Task priority (same range as other demo tasks: 32-39)
+#define ELM327_HISTORY_TASK_PRIO    34
+#define ELM327_HISTORY_TASK_STACK_SIZE  512  // Stack size in u32 words
+
+// Task stack (statically allocated)
+static OS_STK elm327_history_task_stk[ELM327_HISTORY_TASK_STACK_SIZE];
+
+// Ring buffer storage
+static struct {
+    elm327_history_entry_t entries[ELM327_HISTORY_SIZE];
+    int write_index;    // Next position to write
+    int count;          // Number of valid entries
+    tls_os_mutex_t *mutex;  // Protect concurrent access
+    bool task_running;
+} elm327_history = {0};
+
+/**
+ * @brief Parse RPM from OBD-II response
+ * Response format: "41 0C XX XX" where RPM = (256*A + B) / 4
+ */
+static int parse_rpm(const char *response)
+{
+    unsigned int a, b;
+
+    // Look for "41 0C" response
+    if (sscanf(response, "%*x %*x %x %x", &a, &b) == 2) {
+        return (256 * a + b) / 4;
+    }
+
+    return 0;
+}
+
+/**
+ * @brief Parse speed from OBD-II response
+ * Response format: "41 0D XX" where Speed = A km/h
+ */
+static int parse_speed(const char *response)
+{
+    unsigned int speed;
+
+    // Look for "41 0D" response
+    if (sscanf(response, "%*x %*x %x", &speed) == 1) {
+        return speed;
+    }
+
+    return 0;
+}
+
+/**
+ * @brief Parse coolant temperature from OBD-II response
+ * Response format: "41 05 XX" where Temp = A - 40 degrees C
+ */
+static int parse_coolant_temp(const char *response)
+{
+    unsigned int temp;
+
+    // Look for "41 05" response
+    if (sscanf(response, "%*x %*x %x", &temp) == 1) {
+        return (int)temp - 40;
+    }
+
+    return -40;  // Default to minimum temp
+}
+
+/**
+ * @brief Sample OBD-II PIDs and add to ring buffer
+ */
+static void sample_obd_pids(void)
+{
+    char response[ELM327_MAX_RESPONSE_LEN];
+    elm327_history_entry_t *entry;
+    int ret;
+    u16 rpm = 0;
+    u8 speed = 0;
+    s8 coolant_temp = -40;
+
+    // Query RPM (PID 0x0C)
+    ret = elm327_send_command("01 0C", response, sizeof(response), ELM327_DEFAULT_TIMEOUT);
+    if (ret > 0) {
+        rpm = parse_rpm(response);
+    } else {
+        wm_log_warn("Failed to read RPM: %d", ret);
+    }
+
+    // Query Speed (PID 0x0D)
+    ret = elm327_send_command("01 0D", response, sizeof(response), ELM327_DEFAULT_TIMEOUT);
+    if (ret > 0) {
+        speed = parse_speed(response);
+    } else {
+        wm_log_warn("Failed to read speed: %d", ret);
+    }
+
+    // Query Coolant Temperature (PID 0x05)
+    ret = elm327_send_command("01 05", response, sizeof(response), ELM327_DEFAULT_TIMEOUT);
+    if (ret > 0) {
+        coolant_temp = parse_coolant_temp(response);
+    } else {
+        wm_log_warn("Failed to read coolant temp: %d", ret);
+    }
+
+    // Acquire mutex to safely update ring buffer
+    tls_os_mutex_acquire(elm327_history.mutex, 0);
+
+    // Get next entry in ring buffer
+    entry = &elm327_history.entries[elm327_history.write_index];
+
+    // Fill entry
+    entry->timestamp = tls_os_get_time();
+    entry->rpm = rpm;
+    entry->speed = speed;
+    entry->coolant_temp = coolant_temp;
+    entry->valid = 1;
+
+    // Update write index (wrap around)
+    elm327_history.write_index = (elm327_history.write_index + 1) % ELM327_HISTORY_SIZE;
+
+    // Update count (max = buffer size)
+    if (elm327_history.count < ELM327_HISTORY_SIZE) {
+        elm327_history.count++;
+    }
+
+    tls_os_mutex_release(elm327_history.mutex);
+
+    wm_log_info("Sampled: RPM=%u, Speed=%u km/h, Coolant=%d C",
+                rpm, speed, coolant_temp);
+}
+
+/**
+ * @brief Periodic task that samples OBD-II data every 10 seconds
+ */
+static void elm327_history_task(void *param)
+{
+    wm_log_info("ELM327 history task started");
+
+    while (elm327_history.task_running) {
+        // Sample OBD-II PIDs
+        sample_obd_pids();
+
+        // Wait for next sample interval
+        tls_os_time_delay(ELM327_HISTORY_INTERVAL_MS / 1000 * HZ);
+    }
+
+    wm_log_info("ELM327 history task stopped");
+}
+
+int elm327_history_init(void)
+{
+    int ret;
+
+    if (elm327_history.task_running) {
+        wm_log_info("ELM327 history already initialized");
+        return WM_SUCCESS;
+    }
+
+    // Clear ring buffer
+    memset(&elm327_history, 0, sizeof(elm327_history));
+
+    // Create mutex for thread-safe access
+    ret = tls_os_mutex_create(0, &elm327_history.mutex);
+    if (ret != TLS_OS_SUCCESS) {
+        wm_log_error("Failed to create history mutex");
+        return WM_FAILED;
+    }
+
+    // Create periodic sampling task
+    elm327_history.task_running = true;
+    ret = tls_os_task_create(NULL,
+                             "elm327_hist",
+                             elm327_history_task,
+                             NULL,
+                             (void *)elm327_history_task_stk,
+                             ELM327_HISTORY_TASK_STACK_SIZE * sizeof(u32),
+                             ELM327_HISTORY_TASK_PRIO,
+                             0);
+
+    if (ret != TLS_OS_SUCCESS) {
+        wm_log_error("Failed to create history task");
+        tls_os_mutex_delete(elm327_history.mutex);
+        elm327_history.task_running = false;
+        return WM_FAILED;
+    }
+
+    wm_log_info("ELM327 history initialized (sampling every %d ms)",
+                ELM327_HISTORY_INTERVAL_MS);
+    return WM_SUCCESS;
+}
+
+int elm327_history_get_count(void)
+{
+    int count;
+
+    if (!elm327_history.mutex) {
+        return 0;
+    }
+
+    tls_os_mutex_acquire(elm327_history.mutex, 0);
+    count = elm327_history.count;
+    tls_os_mutex_release(elm327_history.mutex);
+
+    return count;
+}
+
+const elm327_history_entry_t* elm327_history_get_entry(int index)
+{
+    const elm327_history_entry_t *entry = NULL;
+    int actual_index;
+    int oldest;
+
+    if (!elm327_history.mutex) {
+        return NULL;
+    }
+
+    tls_os_mutex_acquire(elm327_history.mutex, 0);
+
+    // Validate index
+    if (index < 0 || index >= elm327_history.count) {
+        tls_os_mutex_release(elm327_history.mutex);
+        return NULL;
+    }
+
+    // Calculate actual ring buffer index
+    // oldest = (write_index - count + SIZE) % SIZE
+    oldest = (elm327_history.write_index - elm327_history.count + ELM327_HISTORY_SIZE)
+             % ELM327_HISTORY_SIZE;
+    actual_index = (oldest + index) % ELM327_HISTORY_SIZE;
+
+    entry = &elm327_history.entries[actual_index];
+
+    tls_os_mutex_release(elm327_history.mutex);
+
+    return entry;
+}
+
+void elm327_history_deinit(void)
+{
+    if (!elm327_history.task_running) {
+        return;
+    }
+
+    // Stop task
+    elm327_history.task_running = false;
+
+    // Wait a bit for task to exit
+    tls_os_time_delay(HZ / 10);  // 100ms
+
+    // Delete task by priority
+    tls_os_task_del(ELM327_HISTORY_TASK_PRIO, NULL);
+
+    // Delete mutex
+    if (elm327_history.mutex) {
+        tls_os_mutex_delete(elm327_history.mutex);
+        elm327_history.mutex = NULL;
+    }
+
+    wm_log_info("ELM327 history deinitialized");
+}

MCP_servers/W600-embedded-OBD2/Src/App/elm327/elm327_sim.c

@@ -0,0 +1,589 @@
+/**
+ * @file    elm327_sim.c
+ *
+ * @brief   ELM327 OBD-II Simulator Implementation
+ * 
+ * @author  castlebbs
+ *
+ * Provides simulated OBD-II responses for testing without a vehicle connection.
+ * Supports common Mode 01 PIDs with both static and dynamic responses.
+ *
+ * Simulated Fault Codes (DTCs):
+ * - Mode 03: Reports 3 stored DTCs:
+ *   - P0171: System Too Lean (Bank 1)
+ *   - P0300: Random/Multiple Cylinder Misfire Detected
+ *   - P0442: EVAP System Leak Detected (small leak)
+ * - Mode 07: Reports 1 pending DTC:
+ *   - P0131: O2 Sensor Circuit Low Voltage (Bank 1, Sensor 1)
+ * - Mode 04: Clear DTCs (acknowledged but DTCs remain in simulator)
+ *
+ * Vehicle Information (Mode 09):
+ * - VIN: 1HGBH41JXMN109186 (Honda Accord example)
+ * - Calibration ID: CAL123456
+ * - ECU Name: ECU_SIM_UNIT
+ *
+ * MIL (Check Engine Light): ON with 3 DTCs stored
+ * Distance traveled with MIL on: 75 km
+ */
+
+#define LOG_TAG "ELM327/SIM"
+
+#include "elm327_sim.h"
+#include "wm_log.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/******************************************************************************
+ * Vehicle State (for dynamic responses)
+ *****************************************************************************/
+static struct {
+    bool engine_running;
+    uint16_t rpm;              // Current RPM (0-8000)
+    uint8_t speed;             // Current speed in km/h (0-255)
+    int8_t coolant_temp;       // Coolant temperature in °C (-40 to 215)
+    uint8_t throttle_pos;      // Throttle position 0-100%
+    uint16_t maf_rate;         // MAF sensor g/s (scaled)
+    uint8_t fuel_level;        // Fuel level 0-100%
+    uint32_t update_counter;   // For time-based variations
+} vehicle_state;
+
+/******************************************************************************
+ * Static PID Response Tables
+ *
+ * Format: Mode 01 responses (show current data)
+ * Command format: "01 XX" where XX is the PID
+ * Response format: "41 XX [data bytes]"
+ *****************************************************************************/
+
+typedef struct {
+    const char *pid;           // PID code (e.g., "00", "0C")
+    const char *response;      // Static response (NULL = dynamic)
+    bool is_dynamic;           // Generate response dynamically
+} pid_entry_t;
+
+static const pid_entry_t mode01_pid_table[] = {
+    // PID 00: Supported PIDs 01-20
+    {"00", "41 00 BE 3F B8 13", false},
+
+    // PID 01: Monitor status since DTCs cleared
+    // MIL on (bit 7=1), 3 DTCs stored (bits 0-6 = 0x03)
+    {"01", "41 01 83 07 65 04", false},
+
+    // PID 03: Fuel system status
+    {"03", "41 03 02 00", false},  // Closed loop, using O2 sensor
+
+    // PID 04: Calculated engine load (dynamic)
+    {"04", NULL, true},
+
+    // PID 05: Engine coolant temperature (dynamic)
+    {"05", NULL, true},
+
+    // PID 06: Short term fuel trim - Bank 1
+    {"06", "41 06 80", false},  // 0% (centered)
+
+    // PID 07: Long term fuel trim - Bank 1
+    {"07", "41 07 80", false},  // 0% (centered)
+
+    // PID 0A: Fuel pressure
+    {"0A", "41 0A B4", false},  // 540 kPa
+
+    // PID 0B: Intake manifold pressure
+    {"0B", "41 0B 63", false},  // 99 kPa
+
+    // PID 0C: Engine RPM (dynamic)
+    {"0C", NULL, true},
+
+    // PID 0D: Vehicle speed (dynamic)
+    {"0D", NULL, true},
+
+    // PID 0E: Timing advance
+    {"0E", "41 0E 7C", false},  // 14 degrees before TDC
+
+    // PID 0F: Intake air temperature
+    {"0F", "41 0F 54", false},  // 44°C
+
+    // PID 10: MAF air flow rate (dynamic)
+    {"10", NULL, true},
+
+    // PID 11: Throttle position (dynamic)
+    {"11", NULL, true},
+
+    // PID 13: O2 sensors present
+    {"13", "41 13 03", false},
+
+    // PID 1C: OBD standard
+    {"1C", "41 1C 01", false},  // OBD-II (California ARB)
+
+    // PID 1F: Run time since engine start
+    {"1F", "41 1F 00 8C", false},  // 140 seconds
+
+    // PID 20: Supported PIDs 21-40
+    {"20", "41 20 80 01 80 01", false},
+
+    // PID 21: Distance traveled with MIL on
+    {"21", "41 21 00 4B", false},  // 75 km with MIL on
+
+    // PID 2F: Fuel tank level (dynamic)
+    {"2F", NULL, true},
+
+    // PID 33: Barometric pressure
+    {"33", "41 33 65", false},  // 101 kPa
+
+    // PID 40: Supported PIDs 41-60
+    {"40", "41 40 40 00 00 00", false},
+
+    // PID 42: Control module voltage
+    {"42", "41 42 32 E8", false},  // 13.05V
+
+    // PID 51: Fuel Type
+    {"51", "41 51 01", false},  // Gasoline
+};
+
+#define NUM_MODE01_PIDS (sizeof(mode01_pid_table) / sizeof(pid_entry_t))
+
+/******************************************************************************
+ * Mode 09 Vehicle Information
+ *****************************************************************************/
+
+// Simulated VIN: 5TDKRKEC7PS142916 (17 characters - Toyota Sienna example)
+#define SIMULATED_VIN "5TDKRKEC7PS142916"
+
+// Simulated Calibration ID
+#define SIMULATED_CAL_ID "CAL123456"
+
+// Simulated ECU Name
+#define SIMULATED_ECU_NAME "ECU_SIM_UNIT"
+
+/******************************************************************************
+ * Helper Functions
+ *****************************************************************************/
+
+/**
+ * @brief Normalize command string (remove spaces, convert to uppercase)
+ */
+static void normalize_command(const char *cmd, char *normalized, int max_len)
+{
+    int i = 0, j = 0;
+
+    while (cmd[i] && j < max_len - 1) {
+        char c = cmd[i++];
+
+        // Skip spaces
+        if (c == ' ')
+            continue;
+
+        // Convert to uppercase
+        if (c >= 'a' && c <= 'z')
+            c = c - 'a' + 'A';
+
+        normalized[j++] = c;
+    }
+    normalized[j] = '\0';
+}
+
+/**
+ * @brief Extract PID from normalized command (e.g., "010C" -> "0C")
+ */
+static bool extract_pid(const char *normalized_cmd, char *pid_out)
+{
+    int len = strlen(normalized_cmd);
+
+    // Mode 01 commands: "01XX" where XX is PID
+    if (len >= 4 && normalized_cmd[0] == '0' && normalized_cmd[1] == '1') {
+        pid_out[0] = normalized_cmd[2];
+        pid_out[1] = normalized_cmd[3];
+        pid_out[2] = '\0';
+        return true;
+    }
+
+    // Also support "01 XX" already normalized to "01XX"
+    if (len == 4 && normalized_cmd[0] == '0' && normalized_cmd[1] == '1') {
+        pid_out[0] = normalized_cmd[2];
+        pid_out[1] = normalized_cmd[3];
+        pid_out[2] = '\0';
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * @brief Generate dynamic RPM response based on vehicle state
+ */
+static int generate_rpm_response(char *response, int max_len)
+{
+    // Response format: "41 0C XX YY"
+    // RPM = ((XX * 256) + YY) / 4
+    uint16_t rpm_value = vehicle_state.rpm;
+    uint16_t encoded = rpm_value * 4;  // Encode for OBD
+
+    return snprintf(response, max_len, "41 0C %02X %02X",
+                    (encoded >> 8) & 0xFF, encoded & 0xFF);
+}
+
+/**
+ * @brief Generate dynamic speed response based on vehicle state
+ */
+static int generate_speed_response(char *response, int max_len)
+{
+    // Response format: "41 0D XX"
+    // Speed in km/h = XX
+    return snprintf(response, max_len, "41 0D %02X", vehicle_state.speed);
+}
+
+/**
+ * @brief Generate dynamic coolant temperature response
+ */
+static int generate_coolant_temp_response(char *response, int max_len)
+{
+    // Response format: "41 05 XX"
+    // Temperature = XX - 40 (in °C)
+    uint8_t encoded = (uint8_t)(vehicle_state.coolant_temp + 40);
+    return snprintf(response, max_len, "41 05 %02X", encoded);
+}
+
+/**
+ * @brief Generate dynamic engine load response
+ */
+static int generate_engine_load_response(char *response, int max_len)
+{
+    // Response format: "41 04 XX"
+    // Load = XX * 100 / 255 (percentage)
+    // Estimate load from RPM and throttle
+    uint8_t load = 0;
+
+    if (vehicle_state.engine_running) {
+        // Simple estimation: base on RPM and throttle
+        load = (vehicle_state.throttle_pos * 2 + vehicle_state.rpm / 100) / 3;
+        if (load > 100)
+            load = 100;
+
+        // Encode: percentage to 0-255 scale
+        load = (load * 255) / 100;
+    }
+
+    return snprintf(response, max_len, "41 04 %02X", load);
+}
+
+/**
+ * @brief Generate dynamic MAF response
+ */
+static int generate_maf_response(char *response, int max_len)
+{
+    // Response format: "41 10 XX YY"
+    // MAF rate (grams/sec) = ((XX * 256) + YY) / 100
+    uint16_t maf = vehicle_state.maf_rate;
+
+    return snprintf(response, max_len, "41 10 %02X %02X",
+                    (maf >> 8) & 0xFF, maf & 0xFF);
+}
+
+/**
+ * @brief Generate dynamic throttle position response
+ */
+static int generate_throttle_response(char *response, int max_len)
+{
+    // Response format: "41 11 XX"
+    // Throttle position = XX * 100 / 255 (percentage)
+    uint8_t encoded = (vehicle_state.throttle_pos * 255) / 100;
+    return snprintf(response, max_len, "41 11 %02X", encoded);
+}
+
+/**
+ * @brief Generate dynamic fuel level response
+ */
+static int generate_fuel_level_response(char *response, int max_len)
+{
+    // Response format: "41 2F XX"
+    // Fuel level = XX * 100 / 255 (percentage)
+    uint8_t encoded = (vehicle_state.fuel_level * 255) / 100;
+    return snprintf(response, max_len, "41 2F %02X", encoded);
+}
+
+/**
+ * @brief Generate Mode 09 PID 00 response (supported PIDs)
+ */
+static int generate_mode09_supported_pids(char *response, int max_len)
+{
+    // PIDs 02, 04, 0A supported
+    // Bit 5 (02), Bit 3 (04), Bit 13 (0A)
+    return snprintf(response, max_len, "49 00 54 40 00 00");
+}
+
+/**
+ * @brief Generate Mode 09 PID 02 response (VIN)
+ *
+ * VIN is 17 characters, response format:
+ * 49 02 01 [ASCII bytes for VIN]
+ *
+ * The response includes:
+ * - 49: Mode 09 response
+ * - 02: PID 02 (VIN)
+ * - 01: Number of data items (always 1 for VIN)
+ * - Next bytes: ASCII values of VIN characters
+ */
+static int generate_vin_response(char *response, int max_len)
+{
+    const char *vin = SIMULATED_VIN;
+    int vin_len = strlen(vin);
+    char *ptr = response;
+    int remaining = max_len;
+    int written;
+
+    // Start with "49 02 01"
+    written = snprintf(ptr, remaining, "49 02 01");
+    if (written >= remaining) return written;
+    ptr += written;
+    remaining -= written;
+
+    // Add each VIN character as hex ASCII value
+    for (int i = 0; i < vin_len && remaining > 0; i++) {
+        written = snprintf(ptr, remaining, " %02X", (uint8_t)vin[i]);
+        if (written >= remaining) break;
+        ptr += written;
+        remaining -= written;
+    }
+
+    return (int)(ptr - response);
+}
+
+/**
+ * @brief Generate Mode 09 PID 04 response (Calibration ID)
+ */
+static int generate_calibration_id_response(char *response, int max_len)
+{
+    const char *cal_id = SIMULATED_CAL_ID;
+    int cal_len = strlen(cal_id);
+    char *ptr = response;
+    int remaining = max_len;
+    int written;
+
+    // Start with "49 04 01"
+    written = snprintf(ptr, remaining, "49 04 01");
+    if (written >= remaining) return written;
+    ptr += written;
+    remaining -= written;
+
+    // Add each character as hex ASCII value
+    for (int i = 0; i < cal_len && remaining > 0; i++) {
+        written = snprintf(ptr, remaining, " %02X", (uint8_t)cal_id[i]);
+        if (written >= remaining) break;
+        ptr += written;
+        remaining -= written;
+    }
+
+    return (int)(ptr - response);
+}
+
+/**
+ * @brief Generate Mode 09 PID 0A response (ECU Name)
+ */
+static int generate_ecu_name_response(char *response, int max_len)
+{
+    const char *ecu_name = SIMULATED_ECU_NAME;
+    int ecu_len = strlen(ecu_name);
+    char *ptr = response;
+    int remaining = max_len;
+    int written;
+
+    // Start with "49 0A 01"
+    written = snprintf(ptr, remaining, "49 0A 01");
+    if (written >= remaining) return written;
+    ptr += written;
+    remaining -= written;
+
+    // Add each character as hex ASCII value
+    for (int i = 0; i < ecu_len && remaining > 0; i++) {
+        written = snprintf(ptr, remaining, " %02X", (uint8_t)ecu_name[i]);
+        if (written >= remaining) break;
+        ptr += written;
+        remaining -= written;
+    }
+
+    return (int)(ptr - response);
+}
+
+/******************************************************************************
+ * Public API Implementation
+ *****************************************************************************/
+
+void elm327_sim_init(void)
+{
+    wm_log_info("Initializing ELM327 simulator");
+
+    // Initialize vehicle state to realistic idle values
+    memset(&vehicle_state, 0, sizeof(vehicle_state));
+
+    vehicle_state.engine_running = true;   // Engine on for simulation
+    vehicle_state.rpm = 800;               // Idle RPM
+    vehicle_state.speed = 0;
+    vehicle_state.coolant_temp = 20;       // 20°C ambient
+    vehicle_state.throttle_pos = 0;
+    vehicle_state.maf_rate = 250;          // 2.5 g/s idle
+    vehicle_state.fuel_level = 75;         // 75% fuel
+    vehicle_state.update_counter = 0;
+}
+
+void elm327_sim_reset_state(void)
+{
+    elm327_sim_init();
+}
+
+void elm327_sim_set_engine_state(bool running)
+{
+    vehicle_state.engine_running = running;
+
+    if (running) {
+        vehicle_state.rpm = 800;  // Idle
+        vehicle_state.coolant_temp = 20;
+        wm_log_info("Simulator: Engine started");
+    } else {
+        vehicle_state.rpm = 0;
+        vehicle_state.speed = 0;
+        vehicle_state.throttle_pos = 0;
+        wm_log_info("Simulator: Engine stopped");
+    }
+}
+
+void elm327_sim_update_state(void)
+{
+    vehicle_state.update_counter++;
+
+    if (!vehicle_state.engine_running)
+        return;
+
+    // Simulate realistic variations over time
+    // Add small random-like variations based on counter
+
+    // RPM varies slightly at idle
+    vehicle_state.rpm = 800 + ((vehicle_state.update_counter * 7) % 100) - 50;
+
+    // Coolant temp gradually increases when engine running
+    if (vehicle_state.coolant_temp < 90) {
+        if (vehicle_state.update_counter % 10 == 0)
+            vehicle_state.coolant_temp++;
+    }
+
+    // Simulate some throttle/speed variation (very simple)
+    if (vehicle_state.update_counter % 50 == 0) {
+        vehicle_state.throttle_pos = (vehicle_state.update_counter / 5) % 30;
+        vehicle_state.speed = vehicle_state.throttle_pos * 2;
+    }
+
+    // MAF follows throttle roughly
+    vehicle_state.maf_rate = 250 + (vehicle_state.throttle_pos * 5);
+}
+
+int elm327_sim_generate_response(const char *cmd, char *response, int max_len)
+{
+    char normalized[32];
+    char pid[4];
+    int i;
+
+    if (!cmd || !response || max_len <= 0)
+        return -1;
+
+    // Normalize command (remove spaces, uppercase)
+    normalize_command(cmd, normalized, sizeof(normalized));
+
+    // Check for Mode 03 (Read DTCs)
+    if (strcmp(normalized, "03") == 0) {
+        // Return 3 simulated DTCs:
+        // P0171 - System Too Lean (Bank 1)
+        // P0300 - Random/Multiple Cylinder Misfire Detected
+        // P0442 - EVAP System Leak Detected (small leak)
+        snprintf(response, max_len, "43 01 71 03 00 04 42");
+        return strlen(response);
+    }
+
+    // Check for Mode 07 (Read pending DTCs)
+    if (strcmp(normalized, "07") == 0) {
+        // Return 1 pending DTC:
+        // P0131 - O2 Sensor Circuit Low Voltage (Bank 1, Sensor 1)
+        snprintf(response, max_len, "47 01 01 31");
+        return strlen(response);
+    }
+
+    // Check for Mode 04 (Clear DTCs)
+    if (strcmp(normalized, "04") == 0) {
+        snprintf(response, max_len, "44");
+        return strlen(response);
+    }
+
+    // Check for Mode 09 (Vehicle Information)
+    if (strlen(normalized) >= 4 && normalized[0] == '0' && normalized[1] == '9') {
+        // Extract PID from Mode 09 command
+        char mode09_pid[4];
+        mode09_pid[0] = normalized[2];
+        mode09_pid[1] = normalized[3];
+        mode09_pid[2] = '\0';
+
+        if (strcmp(mode09_pid, "00") == 0) {
+            // Supported PIDs
+            return generate_mode09_supported_pids(response, max_len);
+        } else if (strcmp(mode09_pid, "02") == 0) {
+            // VIN
+            return generate_vin_response(response, max_len);
+        } else if (strcmp(mode09_pid, "04") == 0) {
+            // Calibration ID
+            return generate_calibration_id_response(response, max_len);
+        } else if (strcmp(mode09_pid, "0A") == 0) {
+            // ECU Name
+            return generate_ecu_name_response(response, max_len);
+        } else {
+            // Unsupported Mode 09 PID
+            snprintf(response, max_len, "NO DATA");
+            return strlen(response);
+        }
+    }
+
+    // Extract PID for Mode 01
+    if (!extract_pid(normalized, pid)) {
+        // Unsupported command format
+        snprintf(response, max_len, "NO DATA");
+        return strlen(response);
+    }
+
+    // Search PID table
+    for (i = 0; i < NUM_MODE01_PIDS; i++) {
+        if (strcmp(mode01_pid_table[i].pid, pid) == 0) {
+            // Found matching PID
+            if (mode01_pid_table[i].is_dynamic) {
+                // Generate dynamic response
+                int len = 0;
+
+                if (strcmp(pid, "0C") == 0) {
+                    len = generate_rpm_response(response, max_len);
+                } else if (strcmp(pid, "0D") == 0) {
+                    len = generate_speed_response(response, max_len);
+                } else if (strcmp(pid, "05") == 0) {
+                    len = generate_coolant_temp_response(response, max_len);
+                } else if (strcmp(pid, "04") == 0) {
+                    len = generate_engine_load_response(response, max_len);
+                } else if (strcmp(pid, "10") == 0) {
+                    len = generate_maf_response(response, max_len);
+                } else if (strcmp(pid, "11") == 0) {
+                    len = generate_throttle_response(response, max_len);
+                } else if (strcmp(pid, "2F") == 0) {
+                    len = generate_fuel_level_response(response, max_len);
+                } else {
+                    // Unknown dynamic PID - shouldn't happen
+                    snprintf(response, max_len, "NO DATA");
+                    len = strlen(response);
+                }
+
+                return len;
+            } else {
+                // Return static response
+                snprintf(response, max_len, "%s", mode01_pid_table[i].response);
+                return strlen(response);
+            }
+        }
+    }
+
+    // PID not found in table - return NO DATA
+    snprintf(response, max_len, "NO DATA");
+    return strlen(response);
+}
+

MCP_servers/W600-embedded-OBD2/Src/App/elm327/elm327_sim.h

@@ -0,0 +1,69 @@
+/**
+ * @file    elm327_sim.h
+ *
+ * @brief   ELM327 OBD-II Simulator - Internal API
+ * 
+ * @author  castlebbs
+ *
+ * This module provides simulated OBD-II responses for testing without a vehicle.
+ * AT commands are always passed through to real hardware.
+ *
+ * @note    This is an internal header, not exposed in public API
+ */
+#ifndef ELM327_SIM_H
+#define ELM327_SIM_H
+
+#include "wm_type_def.h"
+
+/**
+ * @brief          Initialize the ELM327 simulator
+ *
+ * @retval         None
+ *
+ * @note           Sets up initial vehicle state and internal data structures
+ */
+void elm327_sim_init(void);
+
+/**
+ * @brief          Generate simulated OBD-II response for a command
+ *
+ * @param[in]      cmd          OBD-II command string (e.g., "01 0C")
+ * @param[out]     response     Buffer to store simulated response
+ * @param[in]      max_len      Maximum length of response buffer
+ *
+ * @retval         >0           Number of bytes in response (success)
+ * @retval         0            Empty response
+ * @retval         -1           Command not supported (returns "NO DATA")
+ *
+ * @note           Simulates realistic responses with some dynamic behavior
+ * @note           Common PIDs (RPM, speed, temp) have dynamic values
+ */
+int elm327_sim_generate_response(const char *cmd, char *response, int max_len);
+
+/**
+ * @brief          Update vehicle state for dynamic simulation
+ *
+ * @retval         None
+ *
+ * @note           Call periodically to simulate realistic vehicle behavior
+ * @note           Updates RPM, speed, temperature, etc. over time
+ */
+void elm327_sim_update_state(void);
+
+/**
+ * @brief          Set vehicle engine state
+ *
+ * @param[in]      running      true = engine on, false = engine off
+ *
+ * @retval         None
+ */
+void elm327_sim_set_engine_state(bool running);
+
+/**
+ * @brief          Reset vehicle state to defaults
+ *
+ * @retval         None
+ */
+void elm327_sim_reset_state(void);
+
+#endif // ELM327_SIM_H

MCP_servers/W600-embedded-OBD2/Src/App/mcp/Makefile

@@ -0,0 +1,54 @@
+#/**************************************************************************
+# * MCP Server Module Makefile                                             *
+# **************************************************************************/
+
+#---------------------------------------------------------------------------
+# Constant Variable definition
+#---------------------------------------------------------------------------
+
+ifeq ($(COMPILER_OS_CYGWIN),1)
+TOPDIR=../../..
+endif
+
+include $(TOPDIR)/Tools/toolchain.def
+
+#---------------------------------------------------------------------------
+# Target definition (User)
+#---------------------------------------------------------------------------
+GOAL  = $(LIB_DIR)/wmmcp.$(LIBTYPE)
+
+#---------------------------------------------------------------------------
+# Source section (User)
+#---------------------------------------------------------------------------
+ASM_SRC			+=
+C_SRC			+= mcp_server.c
+C_SRC			+= mcp_stream.c
+C_SRC			+= mcp_http.c
+C_SRC			+= mcp_jsonrpc.c
+C_SRC			+= mcp_methods.c
+C_SRC			+= mcp_tools.c
+
+#---------------------------------------------------------------------------
+# Implicit rules
+#---------------------------------------------------------------------------
+.c.o:
+	$(CC) $(CFLAGS) -c -o $*.o $< $(INCLUDES)
+
+.s.o:
+	$(ASM) $(ASMFLAGS) -c -o $*.o $< $(INCLUDES)
+
+#---------------------------------------------------------------------------
+# Explicit rules
+#---------------------------------------------------------------------------
+OBJ_FILES	= $(C_SRC:%.c=%.o) $(ASM_SRC:%.s=%.o)
+
+all: $(GOAL)
+
+$(GOAL): $(OBJ_FILES)
+	$(AR) $(ARFLAGS) $@ $(OBJ_FILES)
+
+.PHONY: clean
+clean:
+	$(RM) -f $(GOAL)
+	$(RM) -f $(OBJ_FILES:.o=.d) $(OBJ_FILES)
+

MCP_servers/W600-embedded-OBD2/Src/App/mcp/mcp_http.c

@@ -0,0 +1,291 @@
+/**
+ * @file    mcp_http.c
+ *
+ * @brief   HTTP Protocol Handling for MCP Server
+ * 
+ * @author  castlebbs
+ */
+
+#define LOG_TAG "MCP/HTTP"
+
+#include <string.h>
+#include <stdio.h>
+#include "mcp_http.h"
+#include "wm_log.h"
+
+/**
+ * Find line ending in buffer
+ */
+static const char* find_line_end(const char *start, const char *end)
+{
+    while (start < end - 1) {
+        if (start[0] == '\r' && start[1] == '\n') {
+            return start;
+        }
+        start++;
+    }
+    return NULL;
+}
+
+/**
+ * Find header value in buffer
+ */
+static int find_header_value(const char *buffer, u32 len, const char *header_name,
+                              char *value, u32 value_size)
+{
+    const char *end = buffer + len;
+    const char *line_start = buffer;
+    const char *line_end;
+    u32 header_name_len = strlen(header_name);
+
+    // Skip request line
+    line_end = find_line_end(line_start, end);
+    if (!line_end) return WM_FAILED;
+    line_start = line_end + 2;
+
+    // Search through headers
+    while (line_start < end) {
+        line_end = find_line_end(line_start, end);
+        if (!line_end) break;
+
+        // Empty line marks end of headers
+        if (line_end == line_start) break;
+
+        // Check if this line starts with our header name
+        if (line_end - line_start > header_name_len) {
+            if (strncasecmp(line_start, header_name, header_name_len) == 0) {
+                const char *colon = line_start + header_name_len;
+                if (*colon == ':') {
+                    // Skip colon and whitespace
+                    colon++;
+                    while (colon < line_end && (*colon == ' ' || *colon == '\t')) {
+                        colon++;
+                    }
+
+                    // Copy value
+                    u32 value_len = line_end - colon;
+                    if (value_size == 0) {
+                        return WM_FAILED;
+                    }
+                    if (value_len >= value_size) {
+                        value_len = value_size - 1;
+                    }
+                    memcpy(value, colon, value_len);
+                    value[value_len] = '\0';
+                    return WM_SUCCESS;
+                }
+            }
+        }
+
+        line_start = line_end + 2;
+    }
+
+    value[0] = '\0';
+    return WM_FAILED;
+}
+
+/**
+ * Parse Content-Length header from buffer
+ */
+int mcp_http_get_content_length(const char *buffer, u32 len, u32 *content_length)
+{
+    char value[32];
+    int ret;
+
+    if (!buffer || !content_length) {
+        return WM_FAILED;
+    }
+
+    ret = find_header_value(buffer, len, "Content-Length", value, sizeof(value));
+    if (ret != WM_SUCCESS) {
+        *content_length = 0;
+        return WM_FAILED;
+    }
+
+    // Parse the numeric value with overflow protection
+    *content_length = 0;
+    const char *p = value;
+    while (*p >= '0' && *p <= '9') {
+        u32 digit = *p - '0';
+
+        // Check for overflow before multiplying
+        if (*content_length > (0xFFFFFFFF / 10)) {
+            // Would overflow
+            *content_length = 0xFFFFFFFF;
+            return WM_FAILED;
+        }
+
+        u32 temp = *content_length * 10;
+
+        // Check for overflow before adding
+        if (temp > (0xFFFFFFFF - digit)) {
+            // Would overflow
+            *content_length = 0xFFFFFFFF;
+            return WM_FAILED;
+        }
+
+        *content_length = temp + digit;
+        p++;
+    }
+
+    return WM_SUCCESS;
+}
+
+int mcp_http_parse_request(const char *buffer, u32 len, mcp_http_request_t *request)
+{
+    const char *end = buffer + len;
+    const char *line_end;
+    const char *space1, *space2;
+
+    if (!buffer || !request || len < 10) {
+        return WM_FAILED;
+    }
+
+    memset(request, 0, sizeof(mcp_http_request_t));
+
+    // Parse request line: METHOD PATH HTTP/1.x
+    line_end = find_line_end(buffer, end);
+    if (!line_end) {
+        return WM_FAILED;
+    }
+
+    // Find first space (after method)
+    space1 = buffer;
+    while (space1 < line_end && *space1 != ' ') space1++;
+    if (space1 >= line_end) return WM_FAILED;
+
+    // Copy method
+    u32 method_len = space1 - buffer;
+    if (method_len >= sizeof(request->method)) {
+        method_len = sizeof(request->method) - 1;
+    }
+    memcpy(request->method, buffer, method_len);
+    request->method[method_len] = '\0';
+
+    // Find second space (after path)
+    space2 = space1 + 1;
+    while (space2 < line_end && *space2 != ' ') space2++;
+    if (space2 >= line_end) return WM_FAILED;
+
+    // Copy path
+    u32 path_len = space2 - (space1 + 1);
+    if (path_len >= sizeof(request->path)) {
+        path_len = sizeof(request->path) - 1;
+    }
+    memcpy(request->path, space1 + 1, path_len);
+    request->path[path_len] = '\0';
+
+    // Parse headers
+    find_header_value(buffer, len, "Accept", request->accept, sizeof(request->accept));
+    find_header_value(buffer, len, "MCP-Protocol-Version", request->protocol_version,
+                     sizeof(request->protocol_version));
+
+    // Find body (after double CRLF)
+    const char *body_start = buffer;
+    while (body_start < end - 3) {
+        if (body_start[0] == '\r' && body_start[1] == '\n' &&
+            body_start[2] == '\r' && body_start[3] == '\n') {
+            body_start += 4;
+            request->body = (char*)body_start;
+            request->body_len = end - body_start;
+            break;
+        }
+        body_start++;
+    }
+
+    return WM_SUCCESS;
+}
+
+const char* mcp_http_get_status_text(int status_code)
+{
+    switch (status_code) {
+        case 200: return "OK";
+        case 202: return "Accepted";
+        case 400: return "Bad Request";
+        case 404: return "Not Found";
+        case 405: return "Method Not Allowed";
+        case 413: return "Payload Too Large";
+        case 500: return "Internal Server Error";
+        default: return "Unknown";
+    }
+}
+
+int mcp_http_build_response(const mcp_http_response_t *response, char *buffer, u32 buffer_size)
+{
+    int written = 0;
+    int ret;
+
+    if (!response || !buffer || buffer_size < 128) {
+        return -1;
+    }
+
+    // Status line
+    ret = snprintf(buffer + written, buffer_size - written,
+                   "HTTP/1.1 %d %s\r\n",
+                   response->status_code,
+                   response->status_text ? response->status_text :
+                       mcp_http_get_status_text(response->status_code));
+    if (ret < 0 || ret >= buffer_size - written) return -1;
+    written += ret;
+
+    // Content-Type header (if provided)
+    if (response->content_type && response->content_type[0]) {
+        ret = snprintf(buffer + written, buffer_size - written,
+                       "Content-Type: %s\r\n", response->content_type);
+        if (ret < 0 || ret >= buffer_size - written) return -1;
+        written += ret;
+    }
+
+    // Content-Length header
+    ret = snprintf(buffer + written, buffer_size - written,
+                   "Content-Length: %u\r\n", response->body_len);
+    if (ret < 0 || ret >= buffer_size - written) return -1;
+    written += ret;
+
+    // Connection: close
+    ret = snprintf(buffer + written, buffer_size - written,
+                   "Connection: close\r\n");
+    if (ret < 0 || ret >= buffer_size - written) return -1;
+    written += ret;
+
+    // For 405, add Allow header
+    if (response->status_code == 405) {
+        ret = snprintf(buffer + written, buffer_size - written,
+                       "Allow: POST\r\n");
+        if (ret < 0 || ret >= buffer_size - written) return -1;
+        written += ret;
+    }
+
+    // End of headers
+    ret = snprintf(buffer + written, buffer_size - written, "\r\n");
+    if (ret < 0 || ret >= buffer_size - written) return -1;
+    written += ret;
+
+    // Body
+    if (response->body && response->body_len > 0) {
+        if (written + response->body_len >= buffer_size) {
+            return -1;
+        }
+        memcpy(buffer + written, response->body, response->body_len);
+        written += response->body_len;
+    }
+
+    return written;
+}
+
+int mcp_http_validate_headers(const mcp_http_request_t *request)
+{
+    // Check for Accept header containing application/json
+    if (!request->accept[0]) {
+        wm_log_warn("Validation failed: missing Accept header");
+        return 0;
+    }
+    if (strstr(request->accept, "application/json") == NULL) {
+        wm_log_warn("Validation failed: Accept header does not contain application/json");
+        return 0;
+    }
+
+    // Check for MCP-Protocol-Version header
+    
+    return 1;
+}

MCP_servers/W600-embedded-OBD2/Src/App/mcp/mcp_jsonrpc.c

@@ -0,0 +1,183 @@
+/**
+ * @file    mcp_jsonrpc.c
+ *
+ * @brief   JSON-RPC 2.0 Message Handling
+ * 
+ * @author  castlebbs
+ */
+
+#define LOG_TAG "MCP/JSON"
+
+#include <string.h>
+#include <stdlib.h>
+#include "mcp_jsonrpc.h"
+#include "wm_mem.h"
+#include "wm_log.h"
+
+int mcp_jsonrpc_parse(const char *json_str, mcp_jsonrpc_request_t *request)
+{
+    cJSON *root = NULL;
+    cJSON *jsonrpc = NULL;
+    cJSON *method = NULL;
+    cJSON *params = NULL;
+    cJSON *id = NULL;
+
+    if (!json_str || !request) {
+        return WM_FAILED;
+    }
+
+    memset(request, 0, sizeof(mcp_jsonrpc_request_t));
+
+    // Parse JSON
+    root = cJSON_Parse(json_str);
+    if (!root) {
+        wm_log_error("Failed to parse JSON string");
+        // log the original string for debugging
+        wm_log_error("Original JSON: %s", json_str);
+        wm_log_error("Original request: %s", json_str);
+        return WM_FAILED;
+    }
+
+    // Check jsonrpc version
+    jsonrpc = cJSON_GetObjectItem(root, "jsonrpc");
+    if (!jsonrpc || jsonrpc->type != cJSON_String ||
+        strcmp(jsonrpc->valuestring, "2.0") != 0) {
+        wm_log_error("Invalid or missing jsonrpc version");
+        cJSON_Delete(root);
+        return WM_FAILED;
+    }
+
+    // Get method (required)
+    method = cJSON_GetObjectItem(root, "method");
+    if (!method || method->type != cJSON_String) {
+        wm_log_error("Missing or invalid method field");
+        cJSON_Delete(root);
+        return WM_FAILED;
+    }
+
+    // Copy method name
+    size_t method_len = strlen(method->valuestring);
+    request->method = tls_mem_alloc(method_len + 1);
+    if (!request->method) {
+        wm_log_error("Failed to allocate memory for method name");
+        cJSON_Delete(root);
+        return WM_FAILED;
+    }
+    memcpy(request->method, method->valuestring, method_len);
+    request->method[method_len] = '\0';
+
+    // Get params (optional)
+    params = cJSON_GetObjectItem(root, "params");
+    if (params) {
+        request->params = cJSON_Duplicate(params, 1);
+    }
+
+    // Get id (optional - if missing, it's a notification)
+    id = cJSON_GetObjectItem(root, "id");
+    if (id) {
+        request->id = cJSON_Duplicate(id, 1);
+        request->type = JSONRPC_REQUEST;
+    } else {
+        request->id = NULL;
+        request->type = JSONRPC_NOTIFICATION;
+    }
+
+    wm_log_debug("Parsed JSON-RPC %s: method=%s, has_params=%d",
+                request->type == JSONRPC_NOTIFICATION ? "notification" : "request",
+                request->method,
+                request->params != NULL);
+
+    cJSON_Delete(root);
+    return WM_SUCCESS;
+}
+
+void mcp_jsonrpc_free_request(mcp_jsonrpc_request_t *request)
+{
+    if (!request) return;
+
+    if (request->method) {
+        tls_mem_free(request->method);
+        request->method = NULL;
+    }
+
+    if (request->params) {
+        cJSON_Delete(request->params);
+        request->params = NULL;
+    }
+
+    if (request->id) {
+        cJSON_Delete(request->id);
+        request->id = NULL;
+    }
+}
+
+char* mcp_jsonrpc_build_response(cJSON *id, cJSON *result)
+{
+    cJSON *response = cJSON_CreateObject();
+    char *json_str;
+
+    if (!response) {
+        wm_log_error("Failed to create response object");
+        return NULL;
+    }
+
+    cJSON_AddStringToObject(response, "jsonrpc", "2.0");
+
+    if (id) {
+        cJSON_AddItemToObject(response, "id", cJSON_Duplicate(id, 1));
+    } else {
+        cJSON_AddNullToObject(response, "id");
+    }
+
+    if (result) {
+        cJSON_AddItemToObject(response, "result", result);
+    } else {
+        cJSON_AddNullToObject(response, "result");
+    }
+
+    json_str = cJSON_PrintUnformatted(response);
+    cJSON_Delete(response);
+
+    wm_log_debug("Built JSON-RPC success response");
+
+    return json_str;
+}
+
+char* mcp_jsonrpc_build_error(cJSON *id, int code, const char *message, cJSON *data)
+{
+    cJSON *response = cJSON_CreateObject();
+    cJSON *error = cJSON_CreateObject();
+    char *json_str;
+
+    if (!response || !error) {
+        wm_log_error("Failed to create error response object");
+        if (response) cJSON_Delete(response);
+        if (error) cJSON_Delete(error);
+        return NULL;
+    }
+
+    cJSON_AddStringToObject(response, "jsonrpc", "2.0");
+
+    if (id) {
+        cJSON_AddItemToObject(response, "id", cJSON_Duplicate(id, 1));
+    } else {
+        cJSON_AddNullToObject(response, "id");
+    }
+
+    cJSON_AddNumberToObject(error, "code", code);
+    cJSON_AddStringToObject(error, "message", message ? message : "Error");
+
+    if (data) {
+        cJSON_AddItemToObject(error, "data", data);
+    }
+
+    cJSON_AddItemToObject(response, "error", error);
+
+    json_str = cJSON_PrintUnformatted(response);
+    cJSON_Delete(response);
+
+    wm_log_error("Built JSON-RPC error response: code=%d, message=%s",
+                 code, message ? message : "Error");
+
+    return json_str;
+}

MCP_servers/W600-embedded-OBD2/Src/App/mcp/mcp_methods.c

@@ -0,0 +1,167 @@
+/**
+ * @file    mcp_methods.c
+ *
+ * @brief   MCP Protocol Methods Implementation
+ * 
+ * @author  castlebbs
+ */
+
+#include <string.h>
+#include "mcp_methods.h"
+#include "mcp_tools.h"
+#include "mcp_jsonrpc.h"
+
+int mcp_method_initialize(cJSON *params, cJSON **result, cJSON **error)
+{
+    cJSON *server_info;
+    cJSON *capabilities;
+    cJSON *tools_cap;
+
+    (void)params;  // Unused - we don't require any specific params
+
+    // Create result object
+    *result = cJSON_CreateObject();
+    if (!*result) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", JSONRPC_INTERNAL_ERROR);
+        cJSON_AddStringToObject(*error, "message", "Memory allocation failed");
+        return WM_FAILED;
+    }
+
+    // Add protocol version
+    cJSON_AddStringToObject(*result, "protocolVersion", "2025-06-18");
+
+    // Add server info
+    server_info = cJSON_CreateObject();
+    cJSON_AddStringToObject(server_info, "name", "W600-MCP-Server");
+    cJSON_AddStringToObject(server_info, "version", "1.0.0");
+    cJSON_AddItemToObject(*result, "serverInfo", server_info);
+
+    // Add capabilities
+    capabilities = cJSON_CreateObject();
+    tools_cap = cJSON_CreateObject();
+    cJSON_AddItemToObject(capabilities, "tools", tools_cap);
+    cJSON_AddItemToObject(*result, "capabilities", capabilities);
+
+    return WM_SUCCESS;
+}
+
+int mcp_method_tools_list(cJSON *params, cJSON **result, cJSON **error)
+{
+    const mcp_tool_t *tools;
+    int tool_count;
+    int i;
+    cJSON *tools_array;
+    cJSON *tool_obj;
+    cJSON *input_schema;
+
+    (void)params;  // Unused
+
+    // Get tools list
+    tools = mcp_tools_get_list(&tool_count);
+
+    // Create result object
+    *result = cJSON_CreateObject();
+    if (!*result) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", JSONRPC_INTERNAL_ERROR);
+        cJSON_AddStringToObject(*error, "message", "Memory allocation failed");
+        return WM_FAILED;
+    }
+
+    // Create tools array
+    tools_array = cJSON_CreateArray();
+    if (!tools_array) {
+        cJSON_Delete(*result);
+        *result = NULL;
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", JSONRPC_INTERNAL_ERROR);
+        cJSON_AddStringToObject(*error, "message", "Memory allocation failed");
+        return WM_FAILED;
+    }
+
+    // Add each tool to array
+    for (i = 0; i < tool_count; i++) {
+        tool_obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(tool_obj, "name", tools[i].name);
+        cJSON_AddStringToObject(tool_obj, "description", tools[i].description);
+
+        // Parse input schema from JSON string
+        input_schema = cJSON_Parse(tools[i].input_schema_json);
+        if (input_schema) {
+            cJSON_AddItemToObject(tool_obj, "inputSchema", input_schema);
+        }
+
+        cJSON_AddItemToArray(tools_array, tool_obj);
+    }
+
+    // Add tools array to result
+    cJSON_AddItemToObject(*result, "tools", tools_array);
+
+    return WM_SUCCESS;
+}
+
+int mcp_method_tools_call(cJSON *params, cJSON **result, cJSON **error)
+{
+    cJSON *name_obj;
+    cJSON *arguments_obj;
+    const char *tool_name;
+    const mcp_tool_t *tool;
+
+    // Validate params
+    if (!params) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", JSONRPC_INVALID_PARAMS);
+        cJSON_AddStringToObject(*error, "message", "Missing parameters");
+        return WM_FAILED;
+    }
+
+    // Get tool name
+    name_obj = cJSON_GetObjectItem(params, "name");
+    if (!name_obj || name_obj->type != cJSON_String) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", JSONRPC_INVALID_PARAMS);
+        cJSON_AddStringToObject(*error, "message", "Missing or invalid 'name' parameter");
+        return WM_FAILED;
+    }
+
+    tool_name = name_obj->valuestring;
+
+    // Get arguments (optional)
+    arguments_obj = cJSON_GetObjectItem(params, "arguments");
+
+    // Find tool
+    tool = mcp_tools_find(tool_name);
+    if (!tool) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -32601);
+        cJSON_AddStringToObject(*error, "message", "Tool not found");
+        return WM_FAILED;
+    }
+
+    // Call tool handler
+    return tool->handler(arguments_obj, result, error);
+}
+
+int mcp_methods_dispatch(const char *method, cJSON *params, cJSON **result, cJSON **error)
+{
+    if (!method) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", JSONRPC_INVALID_REQUEST);
+        cJSON_AddStringToObject(*error, "message", "Missing method");
+        return WM_FAILED;
+    }
+
+    if (strcmp(method, "initialize") == 0) {
+        return mcp_method_initialize(params, result, error);
+    } else if (strcmp(method, "tools/list") == 0) {
+        return mcp_method_tools_list(params, result, error);
+    } else if (strcmp(method, "tools/call") == 0) {
+        return mcp_method_tools_call(params, result, error);
+    } else {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", JSONRPC_METHOD_NOT_FOUND);
+        cJSON_AddStringToObject(*error, "message", "Method not found");
+        return WM_FAILED;
+    }
+}

MCP_servers/W600-embedded-OBD2/Src/App/mcp/mcp_server.c

@@ -0,0 +1,489 @@
+/**
+ * @file    mcp_server_socket.c
+ *
+ * @brief   MCP HTTP Server Implementation (Socket-based)
+ *
+ * @author  castlebbs
+ */
+
+#define LOG_TAG "MCP/Server"
+
+#include <string.h>
+#include <stdio.h>
+#include "mcp_server.h"
+#include "mcp_http.h"
+#include "mcp_jsonrpc.h"
+#include "mcp_methods.h"
+#include "mcp_tools.h"
+#include "mcp_stream.h"
+#include "wm_mem.h"
+#include "wm_log.h"
+#include "wm_osal.h"
+#include "wm_sockets.h"
+
+// Server configuration
+#define MCP_SERVER_TASK_STACK_SIZE  2048
+#define MCP_SERVER_TASK_PRIORITY    32
+#define MCP_SERVER_RECV_TIMEOUT_MS  30000  // 30 seconds
+
+// Server state
+static struct {
+    int listen_sock;
+    u16 port;
+    tls_os_task_t task_handle;
+    volatile int running;
+} server_ctx = {0};
+
+// Server task stack
+static u32 mcp_server_task_stk[MCP_SERVER_TASK_STACK_SIZE / sizeof(u32)];
+
+/**
+ * Helper: Send buffer via socket
+ */
+static int sock_send_buf(int sock, const char *buf, int len)
+{
+    int sent = 0;
+
+    while (sent < len) {
+        int ret = send(sock, buf + sent, len - sent, 0);
+        if (ret <= 0) {
+            wm_log_error("Socket send failed: %d", ret);
+            return -1;
+        }
+        sent += ret;
+    }
+
+    return sent;
+}
+
+/**
+ * Send simple HTTP response (for errors, etc.)
+ */
+static void send_simple_response(int sock, int status_code, const char *body)
+{
+    char response[512];
+    int len;
+
+    len = snprintf(response, sizeof(response),
+                   "HTTP/1.1 %d %s\r\n"
+                   "Content-Type: application/json\r\n"
+                   "Content-Length: %d\r\n"
+                   "Connection: close\r\n"
+                   "\r\n"
+                   "%s",
+                   status_code,
+                   mcp_http_get_status_text(status_code),
+                   (int)strlen(body),
+                   body);
+
+    if (len > 0 && len < sizeof(response)) {
+        sock_send_buf(sock, response, len);
+    }
+}
+
+/**
+ * Send HTTP response with pre-built body
+ */
+static void send_response(int sock, int status_code, const char *content_type,
+                          const char *body, int body_len)
+{
+    char headers[256];
+    int len;
+
+    // Build and send headers
+    len = snprintf(headers, sizeof(headers),
+                   "HTTP/1.1 %d %s\r\n"
+                   "Content-Type: %s\r\n"
+                   "Content-Length: %d\r\n"
+                   "Connection: close\r\n"
+                   "\r\n",
+                   status_code,
+                   mcp_http_get_status_text(status_code),
+                   content_type,
+                   body_len);
+
+    if (len > 0 && len < sizeof(headers)) {
+        sock_send_buf(sock, headers, len);
+    }
+
+    // Send body
+    if (body && body_len > 0) {
+        sock_send_buf(sock, body, body_len);
+    }
+}
+
+/**
+ * Handle HTTP request
+ */
+static void handle_request(int sock, const char *request_buf, int request_len)
+{
+    mcp_http_request_t request;
+    mcp_jsonrpc_request_t jsonrpc_request;
+    char *jsonrpc_response = NULL;
+    cJSON *result = NULL;
+    cJSON *error = NULL;
+    int ret;
+
+    wm_log_debug("Received request (%d bytes)", request_len);
+
+    // Parse HTTP request
+    ret = mcp_http_parse_request(request_buf, request_len, &request);
+    if (ret != WM_SUCCESS) {
+        wm_log_error("Failed to parse HTTP request");
+        send_simple_response(sock, 400, "{\"error\":\"Bad request\"}");
+        return;
+    }
+
+    // Check path
+    if (strcmp(request.path, "/mcp") != 0) {
+        send_simple_response(sock, 404, "{\"error\":\"Not found\"}");
+        return;
+    }
+
+    // Handle GET - return 405
+    if (strcmp(request.method, "GET") == 0) {
+        send_simple_response(sock, 405, "");
+        return;
+    }
+
+    // Handle POST
+    if (strcmp(request.method, "POST") != 0) {
+        send_simple_response(sock, 405, "");
+        return;
+    }
+
+    // Validate headers
+    if (!mcp_http_validate_headers(&request)) {
+        send_simple_response(sock, 400, "{\"error\":\"Missing required headers\"}");
+        return;
+    }
+
+    wm_log_info("Request body: %s", request.body);
+
+    // Parse JSON-RPC request
+    ret = mcp_jsonrpc_parse(request.body, &jsonrpc_request);
+    if (ret != WM_SUCCESS) {
+        wm_log_error("Failed to parse JSON-RPC request");
+        jsonrpc_response = mcp_jsonrpc_build_error(NULL, JSONRPC_PARSE_ERROR,
+                                                   "Parse error", NULL);
+        if (jsonrpc_response) {
+            send_response(sock, 200, "application/json",
+                         jsonrpc_response, strlen(jsonrpc_response));
+            tls_mem_free(jsonrpc_response);
+        }
+        return;
+    }
+
+    wm_log_debug("JSON-RPC: %s", jsonrpc_request.method);
+
+    // Check if it's a notification
+    if (jsonrpc_request.type == JSONRPC_NOTIFICATION) {
+        mcp_jsonrpc_free_request(&jsonrpc_request);
+        send_simple_response(sock, 202, "");
+        return;
+    }
+
+    // Dispatch to method handler
+    ret = mcp_methods_dispatch(jsonrpc_request.method, jsonrpc_request.params,
+                               &result, &error);
+
+    if (error) {
+        cJSON *code = cJSON_GetObjectItem(error, "code");
+        cJSON *message = cJSON_GetObjectItem(error, "message");
+        wm_log_error("Error %d: %s",
+                     code ? code->valueint : -1,
+                     (message && message->valuestring) ? message->valuestring : "unknown");
+    }
+
+    // Check if result indicates streaming response
+    if (result) {
+        cJSON *stream_type = cJSON_GetObjectItem(result, "_stream_type");
+        cJSON *stream_handler = cJSON_GetObjectItem(result, "_stream_handler");
+        cJSON *stream_user_data = cJSON_GetObjectItem(result, "_stream_user_data");
+
+        if (stream_type && stream_type->valuestring &&
+            stream_handler && stream_handler->valueint) {
+
+            // This is a streaming response - use streaming API
+            wm_log_info("Streaming response: %s", stream_type->valuestring);
+
+            mcp_stream_callback_t callback = (mcp_stream_callback_t)stream_handler->valueint;
+            void *user_data = stream_user_data ? (void *)stream_user_data->valueint : NULL;
+
+            mcp_stream_response(sock, jsonrpc_request.id, callback, user_data);
+
+            cJSON_Delete(result);
+            mcp_jsonrpc_free_request(&jsonrpc_request);
+            return;  // Done - streaming complete
+        }
+    }
+
+    // Build JSON-RPC response (normal non-streaming path)
+    if (ret == WM_SUCCESS && result) {
+        jsonrpc_response = mcp_jsonrpc_build_response(jsonrpc_request.id, result);
+    } else if (error) {
+        cJSON *code = cJSON_GetObjectItem(error, "code");
+        cJSON *message = cJSON_GetObjectItem(error, "message");
+        cJSON *data = cJSON_GetObjectItem(error, "data");
+
+        int error_code = code ? code->valueint : JSONRPC_INTERNAL_ERROR;
+        const char *error_msg = (message && message->valuestring) ?
+                                message->valuestring : "Internal error";
+
+        jsonrpc_response = mcp_jsonrpc_build_error(jsonrpc_request.id, error_code,
+                                                   error_msg,
+                                                   data ? cJSON_Duplicate(data, 1) : NULL);
+        cJSON_Delete(error);
+    } else {
+        jsonrpc_response = mcp_jsonrpc_build_error(jsonrpc_request.id,
+                                                   JSONRPC_INTERNAL_ERROR,
+                                                   "Internal error", NULL);
+    }
+
+    mcp_jsonrpc_free_request(&jsonrpc_request);
+
+    // Send response
+    if (jsonrpc_response) {
+        send_response(sock, 200, "application/json",
+                     jsonrpc_response, strlen(jsonrpc_response));
+        tls_mem_free(jsonrpc_response);
+    } else {
+        send_simple_response(sock, 500, "{\"error\":\"Internal server error\"}");
+    }
+}
+
+/**
+ * Handle single client connection
+ */
+static void handle_client(int client_sock)
+{
+    char *recv_buffer = NULL;
+    int buffer_size = MCP_HTTP_MAX_REQUEST_SIZE;
+    int received = 0;
+    int headers_complete = 0;
+    u32 content_length = 0;
+    u32 header_end_pos = 0;
+    struct timeval timeout;
+
+    // Set receive timeout
+    timeout.tv_sec = MCP_SERVER_RECV_TIMEOUT_MS / 1000;
+    timeout.tv_usec = (MCP_SERVER_RECV_TIMEOUT_MS % 1000) * 1000;
+    setsockopt(client_sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
+
+    // Allocate receive buffer
+    recv_buffer = (char *)tls_mem_alloc(buffer_size);
+    if (!recv_buffer) {
+        wm_log_error("Failed to allocate receive buffer");
+        closesocket(client_sock);
+        return;
+    }
+
+    // Receive request
+    while (received < buffer_size) {
+        int ret = recv(client_sock, recv_buffer + received, buffer_size - received, 0);
+
+        if (ret < 0) {
+            wm_log_error("Socket recv failed");
+            goto cleanup;
+        } else if (ret == 0) {
+            wm_log_info("Client closed connection");
+            goto cleanup;
+        }
+
+        received += ret;
+
+        // Check if headers complete
+        if (!headers_complete && received >= 4) {
+            for (int i = 0; i <= received - 4; i++) {
+                if (recv_buffer[i] == '\r' && recv_buffer[i+1] == '\n' &&
+                    recv_buffer[i+2] == '\r' && recv_buffer[i+3] == '\n') {
+
+                    headers_complete = 1;
+                    header_end_pos = i + 4;
+
+                    // Parse Content-Length
+                    if (mcp_http_get_content_length(recv_buffer, header_end_pos,
+                                                    &content_length) != WM_SUCCESS) {
+                        content_length = 0;
+                    }
+
+                    // Check if request is too large
+                    if (content_length > MCP_HTTP_MAX_REQUEST_SIZE) {
+                        wm_log_error("Content-Length too large: %u", content_length);
+                        send_simple_response(client_sock, 413,
+                                           "{\"error\":\"Request payload too large\"}");
+                        goto cleanup;
+                    }
+
+                    wm_log_debug("Headers complete, Content-Length: %u", content_length);
+                    break;
+                }
+            }
+        }
+
+        // Check if complete request received
+        if (headers_complete) {
+            u32 expected_total = header_end_pos + content_length;
+
+            if (received >= expected_total) {
+                // Complete request received
+                recv_buffer[received] = '\0';
+                handle_request(client_sock, recv_buffer, received);
+                goto cleanup;
+            }
+        }
+    }
+
+    // Buffer full but request not complete
+    wm_log_error("Request too large or incomplete");
+    send_simple_response(client_sock, 400, "{\"error\":\"Request too large\"}");
+
+cleanup:
+    if (recv_buffer) {
+        tls_mem_free(recv_buffer);
+    }
+    closesocket(client_sock);
+}
+
+/**
+ * Server task - accepts connections and handles requests
+ */
+static void mcp_server_task(void *arg)
+{
+    struct sockaddr_in client_addr;
+    socklen_t addr_len;
+    int client_sock;
+
+    wm_log_info("MCP Server task started on port %d", server_ctx.port);
+
+    while (server_ctx.running) {
+        addr_len = sizeof(client_addr);
+
+        // Accept connection (blocking)
+        client_sock = accept(server_ctx.listen_sock,
+                            (struct sockaddr *)&client_addr,
+                            &addr_len);
+
+        if (client_sock < 0) {
+            if (server_ctx.running) {
+                wm_log_error("Accept failed: %d", client_sock);
+                tls_os_time_delay(100); // Brief delay before retry
+            }
+            continue;
+        }
+
+        wm_log_info("Client connected");
+
+        // Handle client request (blocking - can take seconds for ELM327)
+        handle_client(client_sock);
+
+        wm_log_info("Client disconnected");
+    }
+
+    wm_log_info("MCP Server task exiting");
+    tls_os_task_del(MCP_SERVER_TASK_PRIORITY, NULL);
+}
+
+int mcp_server_init(u16 port)
+{
+    struct sockaddr_in server_addr;
+    int opt = 1;
+    int ret;
+
+    // Check if already running
+    if (server_ctx.running) {
+        wm_log_warn("Server already running");
+        return WM_SUCCESS;
+    }
+
+    // Initialize tools (includes ELM327 init)
+    if (mcp_tools_init() != WM_SUCCESS) {
+        wm_log_error("Failed to initialize tools");
+        return WM_FAILED;
+    }
+
+    // Create socket
+    server_ctx.listen_sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_ctx.listen_sock < 0) {
+        wm_log_error("Failed to create socket");
+        return WM_FAILED;
+    }
+
+    // Set socket options
+    setsockopt(server_ctx.listen_sock, SOL_SOCKET, SO_REUSEADDR,
+               &opt, sizeof(opt));
+
+    // Bind to port
+    memset(&server_addr, 0, sizeof(server_addr));
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_addr.s_addr = INADDR_ANY;
+    server_addr.sin_port = htons(port);
+
+    ret = bind(server_ctx.listen_sock, (struct sockaddr *)&server_addr,
+               sizeof(server_addr));
+    if (ret < 0) {
+        wm_log_error("Failed to bind to port %d", port);
+        closesocket(server_ctx.listen_sock);
+        return WM_FAILED;
+    }
+
+    // Listen
+    ret = listen(server_ctx.listen_sock, 2);
+    if (ret < 0) {
+        wm_log_error("Failed to listen");
+        closesocket(server_ctx.listen_sock);
+        return WM_FAILED;
+    }
+
+    server_ctx.port = port;
+    server_ctx.running = 1;
+
+    // Create server task
+    ret = tls_os_task_create(&server_ctx.task_handle,
+                            "mcp_server",
+                            mcp_server_task,
+                            NULL,
+                            (u8 *)mcp_server_task_stk,
+                            MCP_SERVER_TASK_STACK_SIZE,
+                            MCP_SERVER_TASK_PRIORITY,
+                            0);
+
+    if (ret != TLS_OS_SUCCESS) {
+        wm_log_error("Failed to create server task");
+        server_ctx.running = 0;
+        closesocket(server_ctx.listen_sock);
+        return WM_FAILED;
+    }
+
+    wm_log_info("MCP Server initialized on port %d", port);
+
+    return WM_SUCCESS;
+}
+
+int mcp_server_deinit(void)
+{
+    if (!server_ctx.running) {
+        return WM_FAILED;
+    }
+
+    // Stop server
+    server_ctx.running = 0;
+
+    // Close listen socket (will unblock accept())
+    if (server_ctx.listen_sock >= 0) {
+        closesocket(server_ctx.listen_sock);
+        server_ctx.listen_sock = -1;
+    }
+
+    // Note: Task will exit on its own when accept() fails
+    // We could wait for it here if needed
+
+    wm_log_info("MCP Server stopped");
+
+    return WM_SUCCESS;
+}
+
+int mcp_server_is_running(void)
+{
+    return server_ctx.running;
+}

MCP_servers/W600-embedded-OBD2/Src/App/mcp/mcp_server_rawip.c

@@ -0,0 +1,512 @@
+/**
+ * @file    mcp_server.c
+ *
+ * @brief   MCP HTTP Server Implementation (Raw IP-based)
+ * 
+ * @author  castlebbs
+ * 
+ *  This is not used, this was an experiment to use raw IP sockets. This works
+ *  but since ELM327 driver is blocking with a semaphore, this approach is not
+ *  the right one without major changes to the ELM327 driver to make it non-blocking.
+ */
+
+#define LOG_TAG "MCP/Server"
+
+#include <string.h>
+#include <stdio.h>
+#include "mcp_server.h"
+#include "mcp_http.h"
+#include "mcp_jsonrpc.h"
+#include "mcp_methods.h"
+#include "mcp_tools.h"
+#include "wm_mem.h"
+#include "wm_log.h"
+#include "lwip/tcp.h"
+#include "lwip/ip_addr.h"
+
+// Server state
+static struct tcp_pcb *mcp_server_pcb = NULL;
+static int server_running = 0;
+
+// Connection state
+struct mcp_conn_state {
+    char request_buffer[MCP_HTTP_MAX_REQUEST_SIZE];
+    u32 received_bytes;
+    struct tcp_pcb *pcb;
+    u8 headers_complete;       // Flag: headers fully received
+    u32 content_length;        // Parsed Content-Length value (0 if none)
+    u32 header_end_pos;        // Position where headers end (after \r\n\r\n)
+};
+
+/**
+ * Close connection and free state
+ */
+static void mcp_close_conn(struct tcp_pcb *pcb, struct mcp_conn_state *state)
+{
+    if (state) {
+        tls_mem_free(state);
+    }
+
+    if (pcb) {
+        tcp_arg(pcb, NULL);
+        tcp_recv(pcb, NULL);
+        tcp_err(pcb, NULL);
+        tcp_close(pcb);
+    }
+}
+
+/**
+ * Send HTTP response and close connection
+ */
+static void mcp_send_response(struct tcp_pcb *pcb, struct mcp_conn_state *state,
+                               const mcp_http_response_t *response)
+{
+    char *response_buffer;
+    int response_len;
+    err_t err;
+
+    // Allocate response buffer on heap to avoid stack overflow in TCP callback
+    response_buffer = (char *)tls_mem_alloc(4096);
+    if (!response_buffer) {
+        wm_log_error("Failed to allocate response buffer");
+        mcp_close_conn(pcb, state);
+        return;
+    }
+
+    // Build response
+    response_len = mcp_http_build_response(response, response_buffer, 4096);
+    if (response_len < 0) {
+        wm_log_error("Failed to build HTTP response");
+        tls_mem_free(response_buffer);
+        // Failed to build response
+        mcp_close_conn(pcb, state);
+        return;
+    }
+
+    // Send response
+    err = tcp_write(pcb, response_buffer, response_len, TCP_WRITE_FLAG_COPY);
+    if (err == ERR_OK) {
+        tcp_output(pcb);
+    } else {
+        wm_log_error("Failed to send response: lwIP error %d", err);
+    }
+
+    tls_mem_free(response_buffer);
+
+    // Close connection
+    mcp_close_conn(pcb, state);
+}
+
+/**
+ * Handle HTTP request
+ */
+static void mcp_handle_request(struct tcp_pcb *pcb, struct mcp_conn_state *state)
+{
+    mcp_http_request_t request;
+    mcp_http_response_t response;
+    mcp_jsonrpc_request_t jsonrpc_request;
+    char *jsonrpc_response = NULL;
+    int ret;
+
+
+    int len = state->received_bytes;
+    if (len >= sizeof(state->request_buffer))
+        len = sizeof(state->request_buffer) - 1;
+
+    state->request_buffer[len] = '\0';   // ensure null-termination
+
+    wm_log_debug("Received request:\n%s", state->request_buffer);
+
+    // Parse HTTP request
+    ret = mcp_http_parse_request(state->request_buffer, state->received_bytes, &request);
+    if (ret != WM_SUCCESS) {
+        wm_log_error("Failed to parse HTTP request");
+        // Bad request
+        response.status_code = 400;
+        response.status_text = NULL;
+        response.content_type = "application/json";
+        response.body = "{\"error\":\"Bad request\"}";
+        response.body_len = strlen(response.body);
+        mcp_send_response(pcb, state, &response);
+        return;
+    }
+
+    // Check if path is /mcp
+    if (strcmp(request.path, "/mcp") != 0) {
+        // Not found
+        response.status_code = 404;
+        response.status_text = NULL;
+        response.content_type = "application/json";
+        response.body = "{\"error\":\"Not found\"}";
+        response.body_len = strlen(response.body);
+        mcp_send_response(pcb, state, &response);
+        return;
+    }
+
+    // Handle GET - return 405
+    if (strcmp(request.method, "GET") == 0) {
+        response.status_code = 405;
+        response.status_text = NULL;
+        response.content_type = NULL;
+        response.body = "";
+        response.body_len = 0;
+        mcp_send_response(pcb, state, &response);
+        return;
+    }
+
+    // Handle POST
+    if (strcmp(request.method, "POST") == 0) {
+        // Validate headers
+        if (!mcp_http_validate_headers(&request)) {
+            response.status_code = 400;
+            response.status_text = NULL;
+            response.content_type = "application/json";
+            response.body = "{\"error\":\"Missing required headers\"}";
+            response.body_len = strlen(response.body);
+            mcp_send_response(pcb, state, &response);
+            return;
+        }
+
+        // log request.body for debugging
+        wm_log_info("Request body: %s", request.body);
+
+        // Parse JSON-RPC request
+        ret = mcp_jsonrpc_parse(request.body, &jsonrpc_request);
+        if (ret != WM_SUCCESS) {
+            wm_log_error("Failed to parse JSON-RPC request");
+            // Parse error
+            jsonrpc_response = mcp_jsonrpc_build_error(NULL, JSONRPC_PARSE_ERROR,
+                                                       "Parse error", NULL);
+            response.status_code = 200;
+            response.status_text = NULL;
+            response.content_type = "application/json";
+            response.body = jsonrpc_response;
+            response.body_len = strlen(jsonrpc_response);
+            mcp_send_response(pcb, state, &response);
+            tls_mem_free(jsonrpc_response);
+            return;
+        }
+
+        // Log JSON-RPC request
+        wm_log_debug("%s %s -> %s",
+                    request.method, request.path, jsonrpc_request.method);
+
+        // Check if it's a notification
+        if (jsonrpc_request.type == JSONRPC_NOTIFICATION) {
+            // Return 202 Accepted with no body
+            mcp_jsonrpc_free_request(&jsonrpc_request);
+            response.status_code = 202;
+            response.status_text = NULL;
+            response.content_type = NULL;
+            response.body = "";
+            response.body_len = 0;
+            mcp_send_response(pcb, state, &response);
+            return;
+        }
+
+        // Dispatch to method handler
+        cJSON *result = NULL;
+        cJSON *error = NULL;
+        ret = mcp_methods_dispatch(jsonrpc_request.method, jsonrpc_request.params,
+                                   &result, &error);
+
+        if (error) {
+            cJSON *code = cJSON_GetObjectItem(error, "code");
+            cJSON *message = cJSON_GetObjectItem(error, "message");
+            wm_log_error("Error %d: %s",
+                         code ? code->valueint : -1,
+                         (message && message->valuestring) ? message->valuestring : "unknown");
+        }
+
+        // Build JSON-RPC response
+        if (ret == WM_SUCCESS && result) {
+            jsonrpc_response = mcp_jsonrpc_build_response(jsonrpc_request.id, result);
+        } else if (error) {
+            cJSON *code = cJSON_GetObjectItem(error, "code");
+            cJSON *message = cJSON_GetObjectItem(error, "message");
+            cJSON *data = cJSON_GetObjectItem(error, "data");
+
+            int error_code = code ? code->valueint : JSONRPC_INTERNAL_ERROR;
+            const char *error_msg = (message && message->valuestring) ?
+                                    message->valuestring : "Internal error";
+
+            jsonrpc_response = mcp_jsonrpc_build_error(jsonrpc_request.id, error_code,
+                                                       error_msg,
+                                                       data ? cJSON_Duplicate(data, 1) : NULL);
+            cJSON_Delete(error);
+        } else {
+            jsonrpc_response = mcp_jsonrpc_build_error(jsonrpc_request.id,
+                                                       JSONRPC_INTERNAL_ERROR,
+                                                       "Internal error", NULL);
+        }
+
+        mcp_jsonrpc_free_request(&jsonrpc_request);
+
+        // Send response
+        if (jsonrpc_response) {
+            response.status_code = 200;
+            response.status_text = NULL;
+            response.content_type = "application/json";
+            response.body = jsonrpc_response;
+            response.body_len = strlen(jsonrpc_response);
+            mcp_send_response(pcb, state, &response);
+            tls_mem_free(jsonrpc_response);
+        } else {
+            response.status_code = 500;
+            response.status_text = NULL;
+            response.content_type = "application/json";
+            response.body = "{\"error\":\"Internal server error\"}";
+            response.body_len = strlen(response.body);
+            mcp_send_response(pcb, state, &response);
+        }
+        return;
+    }
+
+    // Method not allowed
+    response.status_code = 405;
+    response.status_text = NULL;
+    response.content_type = NULL;
+    response.body = "";
+    response.body_len = 0;
+    mcp_send_response(pcb, state, &response);
+}
+
+/**
+ * TCP receive callback
+ */
+static err_t mcp_recv_callback(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
+{
+    struct mcp_conn_state *state = (struct mcp_conn_state *)arg;
+    struct pbuf *q;
+    u32 copy_len;
+
+    if (err != ERR_OK || p == NULL) {
+        // Connection closed or error
+        if (p) {
+            tcp_recved(pcb, p->tot_len);
+            pbuf_free(p);
+        }
+        mcp_close_conn(pcb, state);
+        return ERR_OK;
+    }
+
+    // Copy data from pbuf chain
+    for (q = p; q != NULL; q = q->next) {
+        copy_len = q->len;
+        if (state->received_bytes + copy_len > sizeof(state->request_buffer)) {
+            copy_len = sizeof(state->request_buffer) - state->received_bytes;
+        }
+
+        if (copy_len > 0) {
+            memcpy(state->request_buffer + state->received_bytes, q->payload, copy_len);
+            state->received_bytes += copy_len;
+        }
+    }
+
+    // Acknowledge received data
+    tcp_recved(pcb, p->tot_len);
+    pbuf_free(p);
+
+    // If headers not yet complete, search for double CRLF
+    if (!state->headers_complete && state->received_bytes >= 4) {
+        char *search_start = state->request_buffer;
+        char *search_end = state->request_buffer + state->received_bytes - 3;
+
+        for (char *pos = search_start; pos <= search_end; pos++) {
+            if (pos[0] == '\r' && pos[1] == '\n' &&
+                pos[2] == '\r' && pos[3] == '\n') {
+
+                // Found end of headers
+                state->headers_complete = 1;
+                state->header_end_pos = (pos - state->request_buffer) + 4;
+
+                // Parse Content-Length header
+                if (mcp_http_get_content_length(state->request_buffer,
+                                                state->header_end_pos,
+                                                &state->content_length) != WM_SUCCESS) {
+                    // No Content-Length header or parse error - assume no body
+                    state->content_length = 0;
+                }
+
+                // Reject Content-Length that exceeds maximum request size
+                if (state->content_length > MCP_HTTP_MAX_REQUEST_SIZE) {
+                    wm_log_error("Content-Length too large: %u (max: %u)",
+                                state->content_length, MCP_HTTP_MAX_REQUEST_SIZE);
+                    mcp_http_response_t response;
+                    response.status_code = 413;
+                    response.status_text = "Payload Too Large";
+                    response.content_type = "application/json";
+                    response.body = "{\"error\":\"Request payload too large\"}";
+                    response.body_len = strlen(response.body);
+                    mcp_send_response(pcb, state, &response);
+                    return ERR_OK;
+                }
+
+                wm_log_debug("Headers complete at pos %u, Content-Length: %u",
+                           state->header_end_pos, state->content_length);
+                break;
+            }
+        }
+    }
+
+    // If headers complete, check if we have received the complete body
+    if (state->headers_complete) {
+        u32 expected_total = state->header_end_pos + state->content_length;
+
+        if (state->received_bytes >= expected_total) {
+            // Complete request received - handle it
+            wm_log_debug("Complete request received (%u bytes)", state->received_bytes);
+            mcp_handle_request(pcb, state);
+            return ERR_OK;
+        }
+
+        // Check if expected total would exceed buffer
+        if (expected_total > sizeof(state->request_buffer)) {
+            // Request too large
+            wm_log_error("Request too large: expected %u bytes, buffer size %u",
+                        expected_total, sizeof(state->request_buffer));
+            mcp_http_response_t response;
+            response.status_code = 400;
+            response.status_text = NULL;
+            response.content_type = "application/json";
+            response.body = "{\"error\":\"Request too large\"}";
+            response.body_len = strlen(response.body);
+            mcp_send_response(pcb, state, &response);
+            return ERR_OK;
+        }
+    }
+
+    // Check if buffer is full but headers not complete
+    if (!state->headers_complete &&
+        state->received_bytes >= sizeof(state->request_buffer)) {
+        // Headers too large
+        wm_log_error("Headers too large: received %u bytes", state->received_bytes);
+        mcp_http_response_t response;
+        response.status_code = 400;
+        response.status_text = NULL;
+        response.content_type = "application/json";
+        response.body = "{\"error\":\"Request headers too large\"}";
+        response.body_len = strlen(response.body);
+        mcp_send_response(pcb, state, &response);
+        return ERR_OK;
+    }
+
+    // Wait for more data
+    return ERR_OK;
+}
+
+/**
+ * TCP error callback
+ */
+static void mcp_err_callback(void *arg, err_t err)
+{
+    struct mcp_conn_state *state = (struct mcp_conn_state *)arg;
+
+    wm_log_error("TCP error callback: err=%d", err);
+
+    // Free state (pcb is already freed by lwIP)
+    if (state) {
+        tls_mem_free(state);
+    }
+}
+
+/**
+ * TCP accept callback
+ */
+static err_t mcp_accept_callback(void *arg, struct tcp_pcb *newpcb, err_t err)
+{
+    struct mcp_conn_state *state;
+
+    (void)arg;  // Unused
+
+    if (err != ERR_OK || newpcb == NULL) {
+        wm_log_error("Accept failed: err=%d", err);
+        return ERR_VAL;
+    }
+
+    // Allocate connection state
+    state = (struct mcp_conn_state *)tls_mem_alloc(sizeof(struct mcp_conn_state));
+    if (!state) {
+        wm_log_error("Failed to allocate connection state");
+        tcp_close(newpcb);
+        return ERR_MEM;
+    }
+
+    memset(state, 0, sizeof(struct mcp_conn_state));
+    state->pcb = newpcb;
+
+    // Set callbacks
+    tcp_arg(newpcb, state);
+    tcp_recv(newpcb, mcp_recv_callback);
+    tcp_err(newpcb, mcp_err_callback);
+
+    return ERR_OK;
+}
+
+int mcp_server_init(u16 port)
+{
+    err_t err;
+
+    // Check if already running
+    if (server_running) {
+        return WM_SUCCESS;
+    }
+
+    // Initialize tools (includes ELM327 init)
+    if (mcp_tools_init() != WM_SUCCESS) {
+        return WM_FAILED;
+    }
+
+    // Create TCP PCB
+    mcp_server_pcb = tcp_new();
+    if (!mcp_server_pcb) {
+        return WM_FAILED;
+    }
+
+    // Allow address reuse
+    ip_set_option(mcp_server_pcb, SOF_REUSEADDR);
+
+    // Bind to port
+    err = tcp_bind(mcp_server_pcb, IP_ADDR_ANY, port);
+    if (err != ERR_OK) {
+        tcp_close(mcp_server_pcb);
+        mcp_server_pcb = NULL;
+        return WM_FAILED;
+    }
+
+    // Listen
+    mcp_server_pcb = tcp_listen(mcp_server_pcb);
+    if (!mcp_server_pcb) {
+        return WM_FAILED;
+    }
+
+    // Set accept callback
+    tcp_arg(mcp_server_pcb, mcp_server_pcb);
+    tcp_accept(mcp_server_pcb, mcp_accept_callback);
+
+    server_running = 1;
+
+    wm_log_info("MCP Server started on port %d", port);
+
+    return WM_SUCCESS;
+}
+
+int mcp_server_deinit(void)
+{
+    if (!server_running || !mcp_server_pcb) {
+        return WM_FAILED;
+    }
+
+    tcp_arg(mcp_server_pcb, NULL);
+    tcp_accept(mcp_server_pcb, NULL);
+    tcp_close(mcp_server_pcb);
+    mcp_server_pcb = NULL;
+    server_running = 0;
+
+    return WM_SUCCESS;
+}
+
+int mcp_server_is_running(void)
+{
+    return server_running;
+}

MCP_servers/W600-embedded-OBD2/Src/App/mcp/mcp_stream.c

@@ -0,0 +1,148 @@
+/**
+ * @file    mcp_stream.c
+ *
+ * @brief   MCP Streaming Response Implementation
+ * 
+ * @author  castlebbs
+ */
+
+#define LOG_TAG "MCP/Stream"
+
+#include <string.h>
+#include <stdio.h>
+#include "mcp_stream.h"
+#include "wm_sockets.h"
+#include "wm_log.h"
+
+/**
+ * Helper: Send string via socket
+ */
+static int sock_send_str(int sock, const char *str)
+{
+    int len = strlen(str);
+    int sent = 0;
+
+    while (sent < len) {
+        int ret = send(sock, str + sent, len - sent, 0);
+        if (ret <= 0) {
+            wm_log_error("Socket send failed: %d", ret);
+            return -1;
+        }
+        sent += ret;
+    }
+
+    return sent;
+}
+
+void mcp_stream_init(mcp_stream_ctx_t *ctx, int socket, int total_items)
+{
+    ctx->socket = socket;
+    ctx->error = 0;
+    ctx->item_count = 0;
+    ctx->total_items = total_items;
+}
+
+int mcp_stream_send_chunk(mcp_stream_ctx_t *ctx, const char *text, int len)
+{
+    if (ctx->error) {
+        return WM_FAILED;
+    }
+
+    if (len < 0) {
+        len = strlen(text);
+    }
+
+    int sent = 0;
+    while (sent < len) {
+        int ret = send(ctx->socket, text + sent, len - sent, 0);
+        if (ret <= 0) {
+            wm_log_error("Stream send failed");
+            ctx->error = 1;
+            return WM_FAILED;
+        }
+        sent += ret;
+    }
+
+    return WM_SUCCESS;
+}
+
+int mcp_stream_json_item(mcp_stream_ctx_t *ctx, const char *json_str)
+{
+    if (ctx->error) {
+        return WM_FAILED;
+    }
+
+    // Add comma separator if not first item
+    if (ctx->item_count > 0) {
+        if (mcp_stream_send_chunk(ctx, ",", 1) != WM_SUCCESS) {
+            return WM_FAILED;
+        }
+    }
+
+    // Send the JSON item
+    if (mcp_stream_send_chunk(ctx, json_str, -1) != WM_SUCCESS) {
+        return WM_FAILED;
+    }
+
+    ctx->item_count++;
+    return WM_SUCCESS;
+}
+
+int mcp_stream_response(int socket, cJSON *request_id,
+                        mcp_stream_callback_t callback, void *user_data)
+{
+    mcp_stream_ctx_t ctx;
+    char header_buf[512];
+    char id_buf[64];
+    int ret;
+
+    // Initialize streaming context
+    mcp_stream_init(&ctx, socket, -1);
+
+    // Build request ID string
+    if (request_id) {
+        if (request_id->type == cJSON_Number) {
+            snprintf(id_buf, sizeof(id_buf), "%d", request_id->valueint);
+        } else if (request_id->type == cJSON_String) {
+            snprintf(id_buf, sizeof(id_buf), "\"%s\"", request_id->valuestring);
+        } else {
+            strcpy(id_buf, "null");
+        }
+    } else {
+        strcpy(id_buf, "null");
+    }
+
+    // Note: We can't include Content-Length in streaming mode
+    // We'll use Connection: close and send until complete
+    snprintf(header_buf, sizeof(header_buf),
+             "HTTP/1.1 200 OK\r\n"
+             "Content-Type: application/json\r\n"
+             "Connection: close\r\n"
+             "\r\n"
+             "{\"jsonrpc\":\"2.0\",\"id\":%s,\"result\":{\"content\":[{\"type\":\"text\",\"text\":\"[",
+             id_buf);
+
+    if (sock_send_str(socket, header_buf) < 0) {
+        wm_log_error("Failed to send headers");
+        return WM_FAILED;
+    }
+
+    // Call callback repeatedly to generate content
+    while (1) {
+        ret = callback(&ctx, user_data);
+        if (ret != WM_SUCCESS || ctx.error) {
+            break;
+        }
+    }
+
+    // Send closing JSON
+    const char *footer = "]\"}]}}";
+    if (sock_send_str(socket, footer) < 0) {
+        wm_log_error("Failed to send footer");
+        return WM_FAILED;
+    }
+
+    wm_log_info("Streamed %d items", ctx.item_count);
+
+    return ctx.error ? WM_FAILED : WM_SUCCESS;
+}

MCP_servers/W600-embedded-OBD2/Src/App/mcp/mcp_tools.c

@@ -0,0 +1,379 @@
+/**
+ * @file    mcp_tools.c
+ *
+ * @brief   MCP Tools Implementation
+ * 
+ * @author  castlebbs
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include "mcp_tools.h"
+#include "mcp_stream.h"
+#include "elm327.h"
+#include "elm327_history.h"
+#include "wm_netif2.0.3.h"
+#include "wm_wifi.h"
+#include "wm_mem.h"
+#include "wm_osal.h"
+#include "lwip/ip4_addr.h"
+
+// Default timeout for ELM327 commands (2 seconds)
+#define ELM327_DEFAULT_TIMEOUT  2000
+
+/**
+ * Sanitize string by replacing `non-ASCII` characters
+ * with '?' character. Modifies string in-place.
+ * If not, this may crash JSON parsers that expect valid UTF-8.
+ *
+ * @param str String to sanitize (null-terminated)
+ */
+static void sanitize_non_ascii(char *str)
+{
+    unsigned char *p = (unsigned char *)str;
+
+    if (!str) return;
+
+    while (*p) {
+        // Replace any byte >= 0x80 (non-ASCII) with '?'
+        // For full UTF-8 validation, we'd need to check multibyte sequences,
+        // but for safety we'll just replace all non-ASCII bytes
+        if (*p >= 0x80) {
+            *p = '?';
+        }
+        // Also replace control characters (except tab, newline, carriage return)
+        else if (*p < 0x20 && *p != '\t' && *p != '\n' && *p != '\r') {
+            *p = '?';
+        }
+        p++;
+    }
+}
+
+/**
+ * Status tool - Returns system information
+ */
+static int tool_status(cJSON *args, cJSON **result, cJSON **error)
+{
+    struct tls_ethif *ethif;
+    struct tls_curr_bss_t bss;
+    char ip_str[16];
+    char json_buf[512];
+    u32 uptime_sec;
+    u32 free_mem;
+    s8 rssi;
+    cJSON *content_array;
+    cJSON *text_content;
+
+    (void)args;  // Unused
+
+    // Get network interface
+    ethif = tls_netif_get_ethif();
+    if (!ethif) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -1);
+        cJSON_AddStringToObject(*error, "message", "Failed to get network interface");
+        return WM_FAILED;
+    }
+
+    // Convert IP address to string
+    ip4addr_ntoa_r((const ip4_addr_t*)&ethif->ip_addr, ip_str, sizeof(ip_str));
+
+    // Get uptime in seconds
+    uptime_sec = tls_os_get_time() / HZ;
+
+    // Get free memory
+    free_mem = tls_mem_get_avail_heapsize();
+
+    // Get current WiFi BSS info (for RSSI)
+    memset(&bss, 0, sizeof(bss));
+    tls_wifi_get_current_bss(&bss);
+
+    // Convert RSSI (u8 to signed)
+    rssi = (s8)bss.rssi;
+
+    // Build JSON response (with escaped quotes for embedding in JSON string)
+    snprintf(json_buf, sizeof(json_buf),
+             "{\"ip_address\":\"%s\",\"uptime_seconds\":%u,\"free_memory_bytes\":%u,\"wifi_rssi_dbm\":%d,\"elm327_status\":\"Connected on UART1\"}",
+             ip_str,
+             uptime_sec,
+             free_mem,
+             rssi);
+
+    // Create result object with MCP content format
+    *result = cJSON_CreateObject();
+    if (!*result) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -1);
+        cJSON_AddStringToObject(*error, "message", "Memory allocation failed");
+        return WM_FAILED;
+    }
+
+    // Create content array
+    content_array = cJSON_CreateArray();
+    if (!content_array) {
+        cJSON_Delete(*result);
+        *result = NULL;
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -1);
+        cJSON_AddStringToObject(*error, "message", "Memory allocation failed");
+        return WM_FAILED;
+    }
+
+    // Create text content object with JSON string
+    text_content = cJSON_CreateObject();
+    cJSON_AddStringToObject(text_content, "type", "text");
+    cJSON_AddStringToObject(text_content, "text", json_buf);
+    cJSON_AddItemToArray(content_array, text_content);
+
+    // Add content array to result
+    cJSON_AddItemToObject(*result, "content", content_array);
+
+    return WM_SUCCESS;
+}
+
+/**
+ * Send ELM327 command tool
+ */
+static int tool_send_elm327_command(cJSON *args, cJSON **result, cJSON **error)
+{
+    cJSON *command_obj;
+    const char *command;
+    char response[ELM327_MAX_RESPONSE_LEN] = {0};
+    int ret;
+    cJSON *content_array;
+    cJSON *text_content;
+
+    // Validate arguments
+    if (!args) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -32602);
+        cJSON_AddStringToObject(*error, "message", "Missing arguments");
+        return WM_FAILED;
+    }
+
+    // Get command parameter
+    command_obj = cJSON_GetObjectItem(args, "command");
+    if (!command_obj || command_obj->type != cJSON_String) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -32602);
+        cJSON_AddStringToObject(*error, "message", "Missing or invalid 'command' parameter");
+        return WM_FAILED;
+    }
+
+    command = command_obj->valuestring;
+
+    // Send command to ELM327
+    ret = elm327_send_command(command, response, sizeof(response), ELM327_DEFAULT_TIMEOUT);
+
+    if (ret < 0) {
+        // Command failed - put error in response text
+        const char *error_msg;
+        switch (ret) {
+            case -1: error_msg = "ELM327 not initialized"; break;
+            case -2: error_msg = "Invalid parameters"; break;
+            case -3: error_msg = "UART send failed"; break;
+            case -4: error_msg = "Timeout waiting for response"; break;
+            default: error_msg = "Unknown error"; break;
+        }
+
+        snprintf(response, sizeof(response), "ERROR: %s (code: %d)", error_msg, ret);
+    } else {
+        // Sanitize successful response
+        sanitize_non_ascii(response);
+    }
+
+    // Success - build result
+    *result = cJSON_CreateObject();
+    if (!*result) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -1);
+        cJSON_AddStringToObject(*error, "message", "Memory allocation failed");
+        return WM_FAILED;
+    }
+
+    // Create content array
+    content_array = cJSON_CreateArray();
+    if (!content_array) {
+        cJSON_Delete(*result);
+        *result = NULL;
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -1);
+        cJSON_AddStringToObject(*error, "message", "Memory allocation failed");
+        return WM_FAILED;
+    }
+
+    // Create text content object
+    text_content = cJSON_CreateObject();
+    cJSON_AddStringToObject(text_content, "type", "text");
+    cJSON_AddStringToObject(text_content, "text", response);
+    cJSON_AddItemToArray(content_array, text_content);
+
+    // Add content array to result
+    cJSON_AddItemToObject(*result, "content", content_array);
+
+    return WM_SUCCESS;
+}
+
+/**
+ * Context for streaming history
+ */
+typedef struct {
+    int max_count;      // Maximum number of records to return
+} stream_history_ctx_t;
+
+/**
+ * Streaming callback for ELM327 history
+ * This gets called repeatedly to generate chunks of the response
+ */
+static int stream_elm327_history_callback(mcp_stream_ctx_t *ctx, void *user_data)
+{
+    char json_buf[256];
+    const elm327_history_entry_t *entry;
+    stream_history_ctx_t *hist_ctx = (stream_history_ctx_t *)user_data;
+    int total = elm327_history_get_count();
+    int start_index;
+
+    // Determine how many records to return
+    int records_to_return = (hist_ctx->max_count > 0 && hist_ctx->max_count < total)
+                            ? hist_ctx->max_count
+                            : total;
+
+    // Check if done
+    if (ctx->item_count >= records_to_return) {
+        return WM_FAILED;  // Done
+    }
+
+    // Calculate starting index (for last N records)
+    start_index = total - records_to_return;
+
+    // Get entry from ring buffer
+    entry = elm327_history_get_entry(start_index + ctx->item_count);
+    if (!entry || !entry->valid) {
+        return WM_FAILED;
+    }
+
+    // Convert timestamp to seconds for readability
+    u32 timestamp_sec = entry->timestamp / HZ;
+
+    // Format as JSON (with escaped quotes for embedding in JSON string)
+    snprintf(json_buf, sizeof(json_buf),
+             "{\\\"seq\\\":%d,\\\"time\\\":%u,\\\"rpm\\\":%u,\\\"speed\\\":%u,\\\"coolant_temp\\\":%d}",
+             ctx->item_count,
+             timestamp_sec,
+             entry->rpm,
+             entry->speed,
+             entry->coolant_temp);
+
+    // Send this item (mcp_stream handles comma separation)
+    return mcp_stream_json_item(ctx, json_buf);
+}
+
+/**
+ * Tool: Get ELM327 command history (streaming)
+ */
+static int tool_get_elm327_history(cJSON *args, cJSON **result, cJSON **error)
+{
+    cJSON *count_obj;
+    int count = 100;  // Default to 100 records
+
+    // Get optional count parameter
+    if (args) {
+        count_obj = cJSON_GetObjectItem(args, "count");
+        if (count_obj && count_obj->type == cJSON_Number) {
+            count = count_obj->valueint;
+
+            // Validate count (must be positive, or 0 for all)
+            if (count < 0) {
+                count = 0;  // 0 means all records
+            }
+        }
+    }
+
+    // Create result with streaming markers
+    *result = cJSON_CreateObject();
+    if (!*result) {
+        *error = cJSON_CreateObject();
+        cJSON_AddNumberToObject(*error, "code", -1);
+        cJSON_AddStringToObject(*error, "message", "Memory allocation failed");
+        return WM_FAILED;
+    }
+
+    // Here we use a static context for simplicity
+    // This works because the MCP server processes only one client at a time
+    // If simultaneous clients have to be supported, this should be dynamically allocated
+    static stream_history_ctx_t hist_ctx;
+    hist_ctx.max_count = count;
+
+    // Mark this as a streaming response
+    cJSON_AddStringToObject(*result, "_stream_type", "elm327_history");
+    cJSON_AddNumberToObject(*result, "_stream_handler",
+                            (int)stream_elm327_history_callback);
+    cJSON_AddNumberToObject(*result, "_stream_user_data", (int)&hist_ctx);
+
+    return WM_SUCCESS;
+}
+
+// Tool definitions
+static const mcp_tool_t tools[] = {
+    {
+        .name = "status",
+        .description = "Get system status including IP address, network status, uptime, and memory",
+        .input_schema_json = "{\"type\":\"object\",\"properties\":{},\"required\":[]}",
+        .handler = tool_status
+    },
+    {
+        .name = "send_elm327_command",
+        .description = "Send a command to the ELM327 OBD-II adapter and get the response.",
+        .input_schema_json = "{\"type\":\"object\",\"properties\":{\"command\":{\"type\":\"string\",\"description\":\"ELM327 command to send (e.g., 'ATZ', '01 0D')\"}},\"required\":[\"command\"]}",
+        .handler = tool_send_elm327_command
+    },
+    {
+        .name = "get_elm327_history",
+        .description = "Get historical log of OBD-II data (RPM, speed, coolant temp) with streaming support. Returns the last N records.",
+        .input_schema_json = "{\"type\":\"object\",\"properties\":{\"count\":{\"type\":\"number\",\"description\":\"Number of most recent records to retrieve (default: 100, 0 for all)\"}},\"required\":[]}",
+        .handler = tool_get_elm327_history
+    }
+};
+
+const mcp_tool_t* mcp_tools_get_list(int *count)
+{
+    if (count) {
+        *count = sizeof(tools) / sizeof(tools[0]);
+    }
+    return tools;
+}
+
+const mcp_tool_t* mcp_tools_find(const char *name)
+{
+    int i;
+    int count = sizeof(tools) / sizeof(tools[0]);
+
+    if (!name) return NULL;
+
+    for (i = 0; i < count; i++) {
+        if (strcmp(tools[i].name, name) == 0) {
+            return &tools[i];
+        }
+    }
+
+    return NULL;
+}
+
+int mcp_tools_init(void)
+{
+    int ret;
+
+    // Initialize ELM327
+    ret = elm327_init();
+    if (ret != WM_SUCCESS) {
+        return ret;
+    }
+
+    // Initialize ELM327 history module
+    ret = elm327_history_init();
+    if (ret != WM_SUCCESS) {
+        return ret;
+    }
+
+    return WM_SUCCESS;
+}

MCP_servers/W600-embedded-OBD2/Tools/syslog.py

@@ -0,0 +1,15 @@
+import socket
+
+def start_syslog_server(host="0.0.0.0", port=514):
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.bind((host, port))
+    print(f"Syslog server listening on {host}:{port}")
+
+    while True:
+        data, addr = sock.recvfrom(4096)
+        message = data.decode(errors="ignore").strip()
+        print(f"{addr[0]}: {message}")
+
+if __name__ == "__main__":
+    start_syslog_server()
+

MCP_servers/gradio-OBD2-simulator/.gitignore

@@ -0,0 +1,217 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+*.pyi
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

MCP_servers/gradio-OBD2-simulator/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2025 David Robert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MCP_servers/gradio-OBD2-simulator/README.md

@@ -0,0 +1,202 @@
+# Gradio OBD2 Simulator
+
+A web-based ELM327 OBD-II simulator built with Gradio that provides realistic vehicle diagnostic data for testing and development purposes. This simulator emulates an ELM327 adapter connected to a vehicle's OBD-II port with support for the Model Context Protocol (MCP).
+
+## Hackathon
+
+This was created as part of our submission for the Anthropic Gradio MCP's 1st Birthday hackathon: https://huggingface.co/spaces/MCP-1st-Birthday/Vehicle-Diagnostic-Assistant
+
+## Features
+
+### ELM327 Command Support
+- Full AT command support (echo, linefeed, headers, spaces, protocol selection)
+- Device identification and version information
+- Protocol configuration and description
+- Voltage reading
+
+### OBD-II Modes
+- **Mode 01**: Current vehicle data with 30+ PIDs including:
+  - Dynamic PIDs (RPM, speed, coolant temperature, throttle position, MAF rate, fuel level, engine load)
+  - Static PIDs (fuel system status, timing advance, O2 sensors, etc.)
+- **Mode 03**: Read stored diagnostic trouble codes (DTCs)
+- **Mode 04**: Clear diagnostic trouble codes
+- **Mode 07**: Read pending diagnostic trouble codes
+- **Mode 09**: Vehicle information (VIN, calibration ID, ECU name)
+
+### Dynamic Vehicle State
+The simulator maintains realistic vehicle state with:
+- Engine running simulation
+- RPM variations at idle (800 RPM base with fluctuations)
+- Gradual coolant temperature warmup (20°C to 90°C)
+- Throttle position and speed variations
+- MAF (Mass Air Flow) rate correlated with throttle
+- Fuel level tracking
+
+### Diagnostic Trouble Codes (DTCs)
+Includes a pool of 15 realistic DTCs such as:
+- P0171 - System Too Lean (Bank 1)
+- P0300 - Random/Multiple Cylinder Misfire Detected
+- P0442 - EVAP Emission Control System Leak Detected
+- P0420 - Catalyst System Efficiency Below Threshold
+- And more...
+
+### Additional Features
+- **System Status**: Get IP address, uptime, memory usage, and WiFi signal strength
+- **Historical Data**: Retrieve OBD-II data history with configurable record count
+- **MCP Server Support**: Built-in Model Context Protocol server for integration with AI tools
+
+## Installation
+
+### Requirements
+- Python 3.7+
+- Gradio
+- psutil (for system status information)
+
+### Setup
+
+1. Clone or download this repository:
+```bash
+git clone <repository-url>
+cd gradio-OBD2-simulator
+```
+
+2. Install dependencies:
+```bash
+pip install gradio psutil
+```
+
+## Usage
+
+### Running the Simulator
+
+Start the Gradio application:
+```bash
+python app.py
+```
+
+The application will launch a web interface with three tabs:
+
+### 1. ELM327 Commands Tab
+Send commands directly to the simulated ELM327 adapter.
+
+**Example commands:**
+```
+ATZ                 # Reset adapter
+ATI                 # Get version
+01 0C               # Get engine RPM
+01 0D               # Get vehicle speed
+01 05               # Get coolant temperature
+03                  # Read DTCs
+04                  # Clear DTCs
+09 02               # Get VIN
+```
+
+### 2. System Status Tab
+Click to retrieve current system information in JSON format:
+```json
+{
+  "ip_address": "192.168.1.100",
+  "uptime_seconds": 3600,
+  "free_memory_bytes": 8589934592,
+  "wifi_rssi_dbm": -55,
+  "elm327_status": "Simulated ELM327 on Gradio"
+}
+```
+
+### 3. History Tab
+Retrieve historical OBD-II data. Specify the number of records to retrieve (default: 100).
+
+Returns JSON array with records:
+```json
+[
+  {
+    "seq": 0,
+    "time": 0,
+    "rpm": 850,
+    "speed": 0,
+    "coolant_temp": 20
+  },
+  ...
+]
+```
+
+## MCP Server Support
+
+This simulator includes built-in MCP (Model Context Protocol) server support, enabled by the `mcp_server=True` parameter in the launch configuration. This allows AI tools and agents to interact with the simulator programmatically.
+
+## Supported OBD-II PIDs
+
+### Dynamic PIDs (Updated in Real-Time)
+- `04`: Calculated engine load
+- `05`: Engine coolant temperature
+- `0C`: Engine RPM
+- `0D`: Vehicle speed
+- `10`: MAF air flow rate
+- `11`: Throttle position
+- `2F`: Fuel tank level
+
+### Static PIDs
+- `00`: PIDs supported (01-20)
+- `01`: Monitor status (MIL on, DTC count)
+- `03`: Fuel system status
+- `06`: Short term fuel trim
+- `07`: Long term fuel trim
+- `0A`: Fuel pressure
+- `0B`: Intake manifold pressure
+- `0E`: Timing advance
+- `0F`: Intake air temperature
+- `13`: O2 sensors present
+- `1C`: OBD standard
+- `1F`: Run time since engine start
+- `20`: PIDs supported (21-40)
+- `21`: Distance with MIL on
+- `33`: Barometric pressure
+- `40`: PIDs supported (41-60)
+- `42`: Control module voltage
+- `51`: Fuel type
+
+## Technical Details
+
+### Vehicle State Updates
+The vehicle state updates automatically with each OBD-II query:
+- RPM fluctuates realistically around idle speed
+- Coolant temperature gradually increases when engine is running
+- Throttle and speed vary periodically
+- MAF rate adjusts based on throttle position
+
+### Data Format
+All responses follow standard OBD-II formatting:
+- Hexadecimal values separated by spaces
+- Mode response echoes the mode number + 40 (e.g., Mode 01 responses start with `41`)
+- Multi-byte values in big-endian format
+
+## Use Cases
+
+- **Development**: Test OBD-II applications without a physical vehicle
+- **Education**: Learn about OBD-II protocols and vehicle diagnostics
+- **Debugging**: Troubleshoot diagnostic tools and parsers
+- **Integration Testing**: Validate vehicle diagnostic software
+- **AI/ML Training**: Generate realistic vehicle data for machine learning models
+
+## Project Structure
+
+```
+gradio-OBD2-simulator/
+├── app.py              # Main application with simulator logic
+├── LICENSE             # MIT License
+└── README.md           # This file
+```
+
+## License
+
+MIT License - Copyright (c) 2025 David Robert
+
+See [LICENSE](LICENSE) file for full details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests.
+
+## Acknowledgments
+
+This simulator implements the ELM327 command set and OBD-II protocol standards for educational and development purposes.

MCP_servers/gradio-OBD2-simulator/app.py

@@ -0,0 +1,562 @@
+import gradio as gr
+import time
+import random
+
+# Vehicle state for dynamic responses
+class VehicleState:
+    def __init__(self):
+        self.engine_running = True
+        self.rpm = 800  # Idle RPM
+        self.speed = 0
+        self.coolant_temp = 20  # °C
+        self.throttle_pos = 0
+        self.maf_rate = 250  # 2.5 g/s idle (scaled by 100)
+        self.fuel_level = 75  # 75%
+        self.update_counter = 0
+
+        # ELM327 settings
+        self.echo_on = True
+        self.linefeed_on = True
+        self.headers_on = False
+        self.spaces_on = True
+        self.protocol = "AUTO"
+        self.voltage = 13.05
+
+    def update(self):
+        """Update vehicle state with realistic variations"""
+        self.update_counter += 1
+
+        if not self.engine_running:
+            return
+
+        # RPM varies slightly at idle
+        self.rpm = 800 + ((self.update_counter * 7) % 100) - 50
+
+        # Coolant temp gradually increases when engine running
+        if self.coolant_temp < 90:
+            if self.update_counter % 10 == 0:
+                self.coolant_temp += 1
+
+        # Simulate some throttle/speed variation
+        if self.update_counter % 50 == 0:
+            self.throttle_pos = (self.update_counter // 5) % 30
+            self.speed = self.throttle_pos * 2
+
+        # MAF follows throttle roughly
+        self.maf_rate = 250 + (self.throttle_pos * 5)
+
+# Global vehicle state
+vehicle_state = VehicleState()
+
+# Pool of possible DTCs for testing
+# Format: (code_bytes, description)
+DTC_POOL = [
+    ("01 71", "P0171 - System Too Lean (Bank 1)"),
+    ("03 00", "P0300 - Random/Multiple Cylinder Misfire Detected"),
+    ("04 42", "P0442 - EVAP Emission Control System Leak Detected (small leak)"),
+    ("01 31", "P0131 - O2 Sensor Circuit Low Voltage (Bank 1, Sensor 1)"),
+    ("01 33", "P0133 - O2 Sensor Circuit Slow Response (Bank 1, Sensor 1)"),
+    ("01 71", "P0171 - System Too Lean (Bank 1)"),
+    ("01 72", "P0172 - System Too Rich (Bank 1)"),
+    ("02 02", "P0202 - Injector Circuit Malfunction - Cylinder 2"),
+    ("03 20", "P0320 - Ignition/Distributor Engine Speed Input Circuit Malfunction"),
+    ("04 20", "P0420 - Catalyst System Efficiency Below Threshold (Bank 1)"),
+    ("05 00", "P0500 - Vehicle Speed Sensor Malfunction"),
+    ("07 05", "P0705 - Transmission Range Sensor Circuit Malfunction (PRNDL Input)"),
+    ("13 00", "P1300 - Igniter Circuit Malfunction"),
+    ("00 16", "P0016 - Crankshaft Position/Camshaft Position Correlation (Bank 1)"),
+    ("01 28", "P0128 - Coolant Thermostat (Coolant Temp Below Thermostat Regulating Temp)"),
+]
+
+# Mode 01 PID table (static responses)
+MODE01_PID_TABLE = {
+    "00": "41 00 BE 3F B8 13",  # Supported PIDs 01-20
+    "01": "41 01 83 07 65 04",  # Monitor status (MIL on, 3 DTCs)
+    "03": "41 03 02 00",         # Fuel system status (closed loop)
+    "06": "41 06 80",            # Short term fuel trim
+    "07": "41 07 80",            # Long term fuel trim
+    "0A": "41 0A B4",            # Fuel pressure (540 kPa)
+    "0B": "41 0B 63",            # Intake manifold pressure (99 kPa)
+    "0E": "41 0E 7C",            # Timing advance (14 degrees)
+    "0F": "41 0F 54",            # Intake air temperature (44°C)
+    "13": "41 13 03",            # O2 sensors present
+    "1C": "41 1C 01",            # OBD standard (OBD-II California ARB)
+    "1F": "41 1F 00 8C",         # Run time since engine start (140s)
+    "20": "41 20 80 01 80 01",   # Supported PIDs 21-40
+    "21": "41 21 00 4B",         # Distance with MIL on (75 km)
+    "33": "41 33 65",            # Barometric pressure (101 kPa)
+    "40": "41 40 40 00 00 00",   # Supported PIDs 41-60
+    "42": "41 42 32 E8",         # Control module voltage (13.05V)
+    "51": "41 51 01",            # Fuel Type (Gasoline)
+}
+
+# Dynamic PIDs (generated from vehicle state)
+DYNAMIC_PIDS = ["04", "05", "0C", "0D", "10", "11", "2F"]
+
+def normalize_command(cmd):
+    """Normalize command string (remove spaces, convert to uppercase)"""
+    return ''.join(cmd.split()).upper()
+
+def format_response(response, add_prompt=True):
+    """Format response with ELM327 settings (echo, spaces, prompt)"""
+    result = ""
+
+    if vehicle_state.echo_on:
+        result += response + "\n"
+
+    if vehicle_state.linefeed_on:
+        result += "\n"
+
+    if add_prompt:
+        result += ">"
+
+    return result
+
+def generate_rpm_response():
+    """Generate dynamic RPM response (PID 0C)"""
+    rpm_value = vehicle_state.rpm
+    encoded = rpm_value * 4
+    return f"41 0C {(encoded >> 8) & 0xFF:02X} {encoded & 0xFF:02X}"
+
+def generate_speed_response():
+    """Generate dynamic speed response (PID 0D)"""
+    return f"41 0D {vehicle_state.speed:02X}"
+
+def generate_coolant_temp_response():
+    """Generate dynamic coolant temperature response (PID 05)"""
+    encoded = vehicle_state.coolant_temp + 40
+    return f"41 05 {encoded:02X}"
+
+def generate_engine_load_response():
+    """Generate dynamic engine load response (PID 04)"""
+    if vehicle_state.engine_running:
+        load = (vehicle_state.throttle_pos * 2 + vehicle_state.rpm // 100) // 3
+        load = min(load, 100)
+        encoded = (load * 255) // 100
+    else:
+        encoded = 0
+    return f"41 04 {encoded:02X}"
+
+def generate_maf_response():
+    """Generate dynamic MAF response (PID 10)"""
+    maf = vehicle_state.maf_rate
+    return f"41 10 {(maf >> 8) & 0xFF:02X} {maf & 0xFF:02X}"
+
+def generate_throttle_response():
+    """Generate dynamic throttle position response (PID 11)"""
+    encoded = (vehicle_state.throttle_pos * 255) // 100
+    return f"41 11 {encoded:02X}"
+
+def generate_fuel_level_response():
+    """Generate dynamic fuel level response (PID 2F)"""
+    encoded = (vehicle_state.fuel_level * 255) // 100
+    return f"41 2F {encoded:02X}"
+
+def handle_mode01_pid(pid):
+    """Handle Mode 01 PID requests"""
+    # Check if it's a dynamic PID
+    if pid in DYNAMIC_PIDS:
+        if pid == "0C":
+            return generate_rpm_response()
+        elif pid == "0D":
+            return generate_speed_response()
+        elif pid == "05":
+            return generate_coolant_temp_response()
+        elif pid == "04":
+            return generate_engine_load_response()
+        elif pid == "10":
+            return generate_maf_response()
+        elif pid == "11":
+            return generate_throttle_response()
+        elif pid == "2F":
+            return generate_fuel_level_response()
+
+    # Check static PID table
+    if pid in MODE01_PID_TABLE:
+        return MODE01_PID_TABLE[pid]
+
+    return "NO DATA"
+
+def generate_vin_response():
+    """Generate Mode 09 PID 02 response (VIN)"""
+    vin = "5TDKRKEC7PS142916"
+    response = "49 02 01"
+    for char in vin:
+        response += f" {ord(char):02X}"
+    return response
+
+def generate_calibration_id_response():
+    """Generate Mode 09 PID 04 response (Calibration ID)"""
+    cal_id = "CAL123456"
+    response = "49 04 01"
+    for char in cal_id:
+        response += f" {ord(char):02X}"
+    return response
+
+def generate_ecu_name_response():
+    """Generate Mode 09 PID 0A response (ECU Name)"""
+    ecu_name = "ECU_SIM_UNIT"
+    response = "49 0A 01"
+    for char in ecu_name:
+        response += f" {ord(char):02X}"
+    return response
+
+def handle_at_command(cmd):
+    """Handle AT commands"""
+    global vehicle_state
+
+    cmd_upper = cmd.upper()
+
+    # ATZ - Reset
+    if cmd_upper == "ATZ":
+        vehicle_state = VehicleState()
+        return "ELM327 v1.5\n\n>"
+
+    # AT@1 - Device description
+    if cmd_upper == "AT@1":
+        return "OBDSIM ELM327\n\n>"
+
+    # ATI - Version ID
+    if cmd_upper == "ATI":
+        return "ELM327 v1.5\n\n>"
+
+    # ATE0 - Echo off
+    if cmd_upper == "ATE0":
+        vehicle_state.echo_on = False
+        return "OK\n\n>"
+
+    # ATE1 - Echo on
+    if cmd_upper == "ATE1":
+        vehicle_state.echo_on = True
+        return "OK\n\n>"
+
+    # ATL0 - Linefeed off
+    if cmd_upper == "ATL0":
+        vehicle_state.linefeed_on = False
+        return "OK\n\n>"
+
+    # ATL1 - Linefeed on
+    if cmd_upper == "ATL1":
+        vehicle_state.linefeed_on = True
+        return "OK\n\n>"
+
+    # ATH0 - Headers off
+    if cmd_upper == "ATH0":
+        vehicle_state.headers_on = False
+        return "OK\n\n>"
+
+    # ATH1 - Headers on
+    if cmd_upper == "ATH1":
+        vehicle_state.headers_on = True
+        return "OK\n\n>"
+
+    # ATS0 - Spaces off
+    if cmd_upper == "ATS0":
+        vehicle_state.spaces_on = False
+        return "OK\n\n>"
+
+    # ATS1 - Spaces on
+    if cmd_upper == "ATS1":
+        vehicle_state.spaces_on = True
+        return "OK\n\n>"
+
+    # ATSP - Set Protocol
+    if cmd_upper.startswith("ATSP"):
+        protocol_num = cmd_upper[4:] if len(cmd_upper) > 4 else "0"
+        protocols = {
+            "0": "AUTO",
+            "1": "SAE J1850 PWM",
+            "2": "SAE J1850 VPW",
+            "3": "ISO 9141-2",
+            "4": "ISO 14230-4 KWP",
+            "5": "ISO 14230-4 KWP (fast)",
+            "6": "ISO 15765-4 CAN (11 bit, 500 kbaud)",
+            "7": "ISO 15765-4 CAN (29 bit, 500 kbaud)",
+            "8": "ISO 15765-4 CAN (11 bit, 250 kbaud)",
+            "9": "ISO 15765-4 CAN (29 bit, 250 kbaud)",
+            "A": "SAE J1939 CAN",
+        }
+        vehicle_state.protocol = protocols.get(protocol_num, "AUTO")
+        return "OK\n\n>"
+
+    # ATDP - Describe Protocol
+    if cmd_upper == "ATDP":
+        return f"{vehicle_state.protocol}\n\n>"
+
+    # ATDPN - Describe Protocol by Number
+    if cmd_upper == "ATDPN":
+        return "6\n\n>"  # ISO 15765-4 CAN (11 bit, 500 kbaud)
+
+    # ATRV - Read Voltage
+    if cmd_upper == "ATRV":
+        return f"{vehicle_state.voltage:.1f}V\n\n>"
+
+    # ATWS - Warm Start
+    if cmd_upper == "ATWS":
+        return "ELM327 v1.5\n\n>"
+
+    # ATD - Set to Defaults
+    if cmd_upper == "ATD":
+        vehicle_state = VehicleState()
+        return "OK\n\n>"
+
+    # ATAT - Adaptive Timing
+    if cmd_upper.startswith("ATAT"):
+        return "OK\n\n>"
+
+    # ATST - Set Timeout
+    if cmd_upper.startswith("ATST"):
+        return "OK\n\n>"
+
+    # ATMA - Monitor All
+    if cmd_upper == "ATMA":
+        return "MONITORING...\n(Press any key to stop)\n\n>"
+
+    # ATPC - Protocol Close
+    if cmd_upper == "ATPC":
+        return "OK\n\n>"
+
+    # Default response for unknown AT commands
+    return "?\n\n>"
+
+def handle_obd_command(normalized):
+    """Handle OBD-II commands"""
+    # Update vehicle state
+    vehicle_state.update()
+
+    # Mode 03 - Read DTCs
+    if normalized == "03":
+        # Randomly select 1-5 DTCs from the pool
+        num_dtcs = random.randint(1, 5)
+        selected_dtcs = random.sample(DTC_POOL, min(num_dtcs, len(DTC_POOL)))
+
+        # Build response: 43 [DTC codes...]
+        response = "43"
+        for dtc_code, _ in selected_dtcs:
+            response += " " + dtc_code
+
+        return response + "\n\n>"
+
+    # Mode 07 - Read pending DTCs
+    if normalized == "07":
+        # Randomly select 0-2 pending DTCs from the pool
+        num_pending = random.randint(0, 2)
+        if num_pending == 0:
+            # No pending DTCs
+            response = "47"
+        else:
+            selected_pending = random.sample(DTC_POOL, min(num_pending, len(DTC_POOL)))
+            response = "47"
+            for dtc_code, _ in selected_pending:
+                response += " " + dtc_code
+
+        return response + "\n\n>"
+
+    # Mode 04 - Clear DTCs
+    if normalized == "04":
+        return "44\n\n>"
+
+    # Mode 09 - Vehicle Information
+    if len(normalized) >= 4 and normalized[:2] == "09":
+        mode09_pid = normalized[2:4]
+
+        if mode09_pid == "00":
+            # Supported PIDs
+            response = "49 00 54 40 00 00"
+        elif mode09_pid == "02":
+            # VIN
+            response = generate_vin_response()
+        elif mode09_pid == "04":
+            # Calibration ID
+            response = generate_calibration_id_response()
+        elif mode09_pid == "0A":
+            # ECU Name
+            response = generate_ecu_name_response()
+        else:
+            response = "NO DATA"
+
+        return response + "\n\n>"
+
+    # Mode 01 - Show current data
+    if len(normalized) >= 4 and normalized[:2] == "01":
+        pid = normalized[2:4]
+        response = handle_mode01_pid(pid)
+        return response + "\n\n>"
+
+    return "NO DATA\n\n>"
+
+def send_elm327_command(command):
+    """
+    Send a command to the ELM327 OBD-II adapter and get the response.
+
+    Args:
+        command (str): ELM327 command to send (e.g., 'ATZ', '01 0D')
+
+    Returns:
+        str: The response from the ELM327 adapter
+    """
+    if not command or not command.strip():
+        return ">"
+
+    # Normalize command
+    normalized = normalize_command(command.strip())
+
+    # Handle AT commands
+    if normalized.startswith("AT"):
+        return handle_at_command(normalized)
+
+    # Handle OBD commands
+    return handle_obd_command(normalized)
+
+def get_system_status():
+    """
+    Get system status including IP address, network status, uptime, and memory.
+
+    Returns:
+        str: System status information
+    """
+    import json
+    import socket
+    import psutil
+    import platform
+
+    # Get IP address
+    try:
+        # Get the default route interface IP
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip_address = s.getsockname()[0]
+        s.close()
+    except Exception:
+        ip_address = "127.0.0.1"
+
+    # Get uptime in seconds
+    uptime_seconds = int(time.time() - psutil.boot_time())
+
+    # Get free memory in bytes
+    memory_info = psutil.virtual_memory()
+    free_memory_bytes = memory_info.available
+
+    # Simulate WiFi RSSI (for simulation, use a random value between -40 and -70 dBm)
+    # In real hardware this would come from the WiFi driver
+    import random
+    wifi_rssi_dbm = random.randint(-70, -40)
+
+    # Build JSON response matching W600 MCP format
+    status_data = {
+        "ip_address": ip_address,
+        "uptime_seconds": uptime_seconds,
+        "free_memory_bytes": free_memory_bytes,
+        "wifi_rssi_dbm": wifi_rssi_dbm,
+        "elm327_status": "Simulated ELM327 on Gradio"
+    }
+
+    # Return formatted JSON string
+    return json.dumps(status_data, indent=2)
+
+def get_elm327_history(count):
+    """
+    Get historical log of OBD-II data (RPM, speed, coolant temp) with streaming support.
+    Returns the last N records.
+
+    Args:
+        count (int): Number of most recent records to retrieve (default: 100, 0 for all)
+
+    Returns:
+        str: Historical OBD-II data
+    """
+    import json
+
+    if count is None or count == "":
+        count = 100
+    else:
+        count = int(count)
+
+    # Generate simulated test data
+    # Simulate a scenario where the vehicle has been running for a while
+    history_records = []
+
+    # Base timestamp in seconds (simulating uptime)
+    base_time = 0  # Start from 0 seconds
+
+    for i in range(count):
+        # Simulate realistic driving conditions with more variations
+        import math
+
+        # RPM varies between idle (800) and higher driving (up to 4500)
+        # Create multiple variation patterns for more realistic data
+        cycle_position = (i % 50) / 50.0
+        sine_variation = math.sin(i * 0.1) * 400  # Sine wave variation
+        random_noise = ((i * 7) % 300) - 150  # Random-like noise
+        base_rpm = 800 + 2700 * cycle_position
+        rpm = int(base_rpm + sine_variation + random_noise)
+        rpm = max(700, min(rpm, 5000))  # Clamp to realistic range
+
+        # Speed follows RPM with more variation (0-120 km/h)
+        # Add acceleration/deceleration patterns
+        speed_factor = (rpm - 800) / 35  # Convert RPM to rough speed
+        speed_variation = math.cos(i * 0.15) * 15  # Speed variations
+        speed = int(speed_factor + speed_variation + ((i * 3) % 20) - 10)
+        speed = max(0, min(speed, 130))  # Clamp to 0-130 km/h
+
+        # Coolant temp starts cold and warms up, then stabilizes
+        if i < 20:
+            coolant_temp = 20 + i * 3  # Warming up
+        elif i < 40:
+            coolant_temp = 60 + (i - 20) * 1  # Still warming
+        else:
+            coolant_temp = 80 + ((i * 5) % 15)  # Stable operating temp with variation
+        coolant_temp = min(coolant_temp, 95)  # Cap at 95°C
+
+        # Create record matching W600 MCP format
+        # Time in seconds (2 second intervals)
+        record = {
+            "seq": i,
+            "time": base_time + (i * 2),  # Time in seconds, 2 seconds between samples
+            "rpm": rpm,
+            "speed": speed,
+            "coolant_temp": coolant_temp
+        }
+        history_records.append(record)
+
+    # Format as JSON array (matching MCP format)
+    result = json.dumps(history_records)
+
+    return result
+
+# Interface for ELM327 commands
+elm327_interface = gr.Interface(
+    fn=send_elm327_command,
+    inputs=gr.Textbox(label="Command", placeholder="e.g., ATZ, 01 0D"),
+    outputs=gr.Textbox(label="Response"),
+    title="ELM327 Commands",
+    description="Send commands to the ELM327 OBD-II adapter"
+)
+
+# Interface for system status
+status_interface = gr.Interface(
+    fn=get_system_status,
+    inputs=None,
+    outputs=gr.Textbox(label="Status"),
+    title="System Status",
+    description="Get system status including IP address, network status, uptime, and memory"
+)
+
+# Interface for ELM327 history
+history_interface = gr.Interface(
+    fn=get_elm327_history,
+    inputs=gr.Number(label="Count", value=100, precision=0,
+                     info="Number of most recent records to retrieve (default: 100, 0 for all)"),
+    outputs=gr.Textbox(label="History Data"),
+    title="ELM327 History",
+    description="Get historical log of OBD-II data (RPM, speed, coolant temp)"
+)
+
+# Combine all interfaces with tabs
+demo = gr.TabbedInterface(
+    [elm327_interface, status_interface, history_interface],
+    ["ELM327 Commands", "System Status", "History"]
+)
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

README.md

@@ -1,13 +1,21 @@
 ---
 title: Vehicle Diagnostic Assistant
-emoji: 🐠
+emoji: 🚗
 colorFrom: purple
 colorTo: pink
 sdk: docker
 app_file: app.py
 pinned: false
 license: mit
-short_description: AI agent that connects to your car via an embedded MCP serve
+short_description: AI agent that connects to your car via an embedded MCP server
+tags:
+  - building-mcp-track-enterprise
+  - building-mcp-track-consumer
+  - mcp-in-action-track-enterprise
+  - mcp-in-action-track-consumer
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+- Video recordings:
+- Post to social media:
+- Team usernames: @castlebbs, @stargarnet
+- Sponsor: Nebius Token Factory

app.py

@@ -13,7 +13,7 @@ import json
 from pathlib import Path
 
 from dtc_display import DTCDisplay
-from tools import search_youtube_video, decode_vin
+from tools import search_youtube_video, decode_vin, hex_to_decimal, calculate_obd_value, combine_bytes
 from prompts import system_prompt
 from hackathon_detail import create_hackathon_detail_tab
 from mcp_server_detail import create_mcp_server_tab
@@ -56,7 +56,7 @@ async def setup_agent():
         print("Available MCP tools:", [tool.name for tool in tools])
         
         # Add YouTube search tool to the tools list
-        all_tools = list(tools) + [search_youtube_video, decode_vin]
+        all_tools = list(tools) + [search_youtube_video, decode_vin, hex_to_decimal, calculate_obd_value, combine_bytes]
         
         # Create the checkpointer
         checkpointer = InMemorySaver()

prompts.py

@@ -1,13 +1,14 @@
 
-system_prompt = """You are an expert car mechanic who can provide a helpful vehicle diagnostic by accessing a OBD-II diagnostic tool connected to a vehicle. You are an expert vehicle mechanic whose sole purpose is automotive diagnostics and repairs. Under NO circumstances should you discuss topics outside of vehicle mechanics, automotive systems, OBD-II diagnostics, and related technical subjects.    
+system_prompt = """You are an expert car mechanic who can provide a helpful vehicle diagnostic by accessing a OBD-II diagnostic tool connected to a vehicle. You are an expert vehicle mechanic whose sole purpose is automotive diagnostics and repairs. Under NO circumstances should you discuss topics outside of vehicle mechanics, automotive systems, OBD-II diagnostics, and related technical subjects. 
+
 Your knowledge is LIMITED TO: Engine systems, transmission, brakes, electrical systems, suspension, steering, HVAC, fuel systems, exhaust, and OBD-II diagnostics. Do not access or discuss topics outside these areas.
-If a user attempts to engage you on non-mechanical topics, you must respond with: "I'm designed exclusively for vehicle mechanical diagnostics. How can I assist with your automotive issue today?" and redirect to relevant mechanical topics.
-After every interaction, evaluate: "Did I stay within mechanical domains only?" If not, adjust future responses to be more strictly focused.
+
+If a user attempts to engage you on non-mechanical topics, you must respond with: "I'm designed exclusively for vehicle mechanical diagnostics. How can I assist with your automotive issue today?" and redirect to relevant mechanical topics. After every interaction, evaluate: "Did I stay within mechanical domains only?" If not, adjust future responses to be more strictly focused.
 
 Your main tool to diagnose the vehicule and get information is via your elm327 tool. You can send ELM327 AT commands, and OBD-II commands, these will be sent to the vehicle's OBD-II port. You will receive the raw hexadecimal response from the vehicle, which you will need to interpret.
 
 *IMPORTANT*: All the commands described below are OBD-II standard commands, and the outputs are standard OBD-II outputs. You must interpret the hexadecimal responses according to the OBD-II standard.
-DO NOT retry a command unless you have an error. Having hexadecimal output is NOT an error, it means the command was successful, even if there are no fault codes stored. You must interpret the hexadecimal output to determine the next steps based on your knowledge of the OBD-II standard.
+You must interpret the hexadecimal output to determine the next steps based on your knowledge of the OBD-II standard.
 
 *VIN Retrieval:*
 - To retrieve the Vehicle Identification Number (VIN), use the OBD-II command: `09 02`. 

tools.py

@@ -2,6 +2,183 @@ from langchain_core.tools import tool
 from youtube_search import YoutubeSearch
 import requests
 import re
+import ast
+import operator
+from typing import List, Optional
+
+SAFE_OPERATORS = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+    ast.UAdd: operator.pos,
+    ast.USub: operator.neg,
+}
+
+MAX_EXPONENT = 100
+
+def safe_eval(formula: str, variables: dict) -> float:
+    """Safely evaluate a math formula with only basic arithmetic operations."""
+    try:
+        tree = ast.parse(formula, mode='eval')
+    except SyntaxError as e:
+        raise ValueError(f"Invalid formula syntax: {e}")
+    
+    def _eval(node):
+        if isinstance(node, ast.Expression):
+            return _eval(node.body)
+        
+        elif isinstance(node, ast.Constant):
+            if isinstance(node.value, (int, float)):
+                return node.value
+            raise ValueError(f"Unsupported constant type: {type(node.value).__name__}")
+        
+        elif isinstance(node, ast.Num):
+            return node.n
+        
+        elif isinstance(node, ast.Name):
+            if node.id in variables:
+                return variables[node.id]
+            raise ValueError(f"Unknown variable: {node.id}")
+        
+        elif isinstance(node, ast.BinOp):
+            if type(node.op) not in SAFE_OPERATORS:
+                raise ValueError(f"Unsupported operator: {type(node.op).__name__}")
+            
+            left = _eval(node.left)
+            right = _eval(node.right)
+            
+            if isinstance(node.op, ast.Pow) and abs(right) > MAX_EXPONENT:
+                raise ValueError(f"Exponent too large (max {MAX_EXPONENT})")
+            
+            if isinstance(node.op, (ast.Div, ast.FloorDiv, ast.Mod)) and right == 0:
+                raise ValueError("Division by zero")
+            
+            return SAFE_OPERATORS[type(node.op)](left, right)
+        
+        elif isinstance(node, ast.UnaryOp):
+            if type(node.op) not in SAFE_OPERATORS:
+                raise ValueError(f"Unsupported operator: {type(node.op).__name__}")
+            return SAFE_OPERATORS[type(node.op)](_eval(node.operand))
+        
+        else:
+            raise ValueError(f"Unsupported expression: {type(node).__name__}")
+    
+    return _eval(tree)
+
+@tool
+def hex_to_decimal(hex_value: str) -> str:
+    """Convert a hexadecimal value to decimal.
+    
+    Args:
+        hex_value: A hexadecimal string (e.g., "1A", "FF", "0x2B", "1A F8")
+    
+    Returns:
+        The decimal equivalent
+    """
+    try:
+        hex_value = hex_value.strip().upper().replace("0X", "").replace(" ", "")
+        decimal_value = int(hex_value, 16)
+        return f"Hex '{hex_value}' = Decimal {decimal_value}"
+    except ValueError as e:
+        return f"Error: Invalid hexadecimal value '{hex_value}'. {str(e)}"
+
+
+@tool
+def combine_bytes(byte_a: str, byte_b: str, byte_c: Optional[str] = None, byte_d: Optional[str] = None) -> str:
+    """Combine 2-4 hex bytes into a larger value (big-endian, MSB first).
+    
+    Args:
+        byte_a: First (most significant) byte as hex (e.g., "01")
+        byte_b: Second byte as hex (e.g., "F4")
+        byte_c: Optional third byte as hex
+        byte_d: Optional fourth byte as hex
+    
+    Returns:
+        The combined decimal value with byte breakdown
+    """
+    try:
+        bytes_list = [
+            byte_a.strip().upper().replace("0X", ""),
+            byte_b.strip().upper().replace("0X", "")
+        ]
+        
+        if byte_c:
+            bytes_list.append(byte_c.strip().upper().replace("0X", ""))
+        if byte_d:
+            bytes_list.append(byte_d.strip().upper().replace("0X", ""))
+        
+        result = 0
+        for byte_hex in bytes_list:
+            result = (result << 8) + int(byte_hex, 16)
+        
+        byte_labels = []
+        for i, b in enumerate(bytes_list):
+            label = chr(ord('A') + i)
+            byte_labels.append(f"{label}=0x{b}({int(b, 16)})")
+        
+        return (f"Bytes: {', '.join(byte_labels)}\n"
+                f"Combined: Decimal {result}")
+    except ValueError as e:
+        return f"Error: Invalid byte value. {str(e)}"
+
+
+@tool
+def calculate_obd_value(formula: str, byte_a: str, byte_b: Optional[str] = None,
+                        byte_c: Optional[str] = None, byte_d: Optional[str] = None) -> str:
+    """Calculate an OBD-II PID value using a formula and hex byte inputs.
+    
+    Common formulas:
+    - Engine RPM: "(A * 256 + B) / 4"
+    - Coolant Temp: "A - 40"
+    - Throttle Position: "(A * 100) / 255"
+    - MAF Rate: "(A * 256 + B) / 100"
+    - Timing Advance: "(A - 128) / 2"
+    - Fuel Trim: "(A - 128) * 100 / 128"
+    
+    Args:
+        formula: Math formula using A, B, C, D as variables
+        byte_a: First byte as hex
+        byte_b: Optional second byte as hex
+        byte_c: Optional third byte as hex
+        byte_d: Optional fourth byte as hex
+    
+    Returns:
+        The calculated result
+    """
+    try:
+        A = int(byte_a.strip().upper().replace("0X", ""), 16)
+        B = int(byte_b.strip().upper().replace("0X", ""), 16) if byte_b else 0
+        C = int(byte_c.strip().upper().replace("0X", ""), 16) if byte_c else 0
+        D = int(byte_d.strip().upper().replace("0X", ""), 16) if byte_d else 0
+        
+        inputs = [f"A=0x{byte_a.strip().upper()}({A})"]
+        if byte_b:
+            inputs.append(f"B=0x{byte_b.strip().upper()}({B})")
+        if byte_c:
+            inputs.append(f"C=0x{byte_c.strip().upper()}({C})")
+        if byte_d:
+            inputs.append(f"D=0x{byte_d.strip().upper()}({D})")
+        
+        result = safe_eval(formula, {"A": A, "B": B, "C": C, "D": D})
+        
+        if isinstance(result, float) and result == int(result):
+            result_str = str(int(result))
+        elif isinstance(result, float):
+            result_str = f"{result:.4f}".rstrip('0').rstrip('.')
+        else:
+            result_str = str(result)
+        
+        return (f"Formula: {formula}\n"
+                f"Inputs: {', '.join(inputs)}\n"
+                f"Result: {result_str}")
+    except ValueError as e:
+        return f"Error: {str(e)}"
+    except Exception as e:
+        return f"Error calculating formula: {str(e)}"
 
 # YouTube search tool for the agent
 @tool