I have take the mqtt_publisher sample in the zephyr-project repo and I added a wi-fi connection ot it.
I’m using a esp32_devkitc_wroom.
Here is the main.c:

#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(net_mqtt_publisher_sample, LOG_LEVEL_DBG);

#include <zephyr/kernel.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/wifi_mgmt.h>
#include <zephyr/net/net_event.h>
#include <zephyr/net/socket.h>
#include <zephyr/net/mqtt.h>
#include <zephyr/random/random.h>
#include <zephyr/linker/sections.h>
#include <zephyr/net/net_core.h>
#include <zephyr/net/net_mgmt.h>
#include <zephyr/net/dns_resolve.h>
#include <zephyr/data/json.h>
#include <zephyr/net/net_context.h>

#include <zephyr/sys/printk.h>
#include <string.h>
#include <errno.h>

#include "config.h"
#include "net_sample_common.h"
#include "wifi_cred.h"

#if defined(CONFIG_USERSPACE)
#include <zephyr/app_memory/app_memdomain.h>
K_APPMEM_PARTITION_DEFINE(app_partition);
struct k_mem_domain app_domain;
#define APP_BMEM K_APP_BMEM(app_partition)
#define APP_DMEM K_APP_DMEM(app_partition)
#else
#define APP_BMEM
#define APP_DMEM
#endif

#define SOCKS5_PROXY_PORT 1080  // Replace with your actual SOCKS5 proxy port
#define SOCKS5_PROXY_ADDR "192.168.1.1"

static K_SEM_DEFINE(wifi_connected, 0, 1);              // added
static K_SEM_DEFINE(ipv4_address_obtained, 0, 1);       // added

static struct net_mgmt_event_callback wifi_cb;          // added
static struct net_mgmt_event_callback ipv4_cb;          // added

/* Buffers for MQTT client. */
static APP_BMEM uint8_t rx_buffer[APP_MQTT_BUFFER_SIZE];
static APP_BMEM uint8_t tx_buffer[APP_MQTT_BUFFER_SIZE];

#if defined(CONFIG_MQTT_LIB_WEBSOCKET)
/* Making RX buffer large enough that the full IPv6 packet can fit into it */
#define MQTT_LIB_WEBSOCKET_RECV_BUF_LEN 1280

/* Websocket needs temporary buffer to store partial packets */
static APP_BMEM uint8_t temp_ws_rx_buf[MQTT_LIB_WEBSOCKET_RECV_BUF_LEN];
#endif

/* The mqtt client struct */
static APP_BMEM struct mqtt_client client_ctx;

/* MQTT Broker details. */
static APP_BMEM struct sockaddr_storage broker;

#if defined(CONFIG_SOCKS)
static APP_BMEM struct sockaddr socks5_proxy;
#endif

static APP_BMEM struct pollfd fds[1];
static APP_BMEM int nfds;

static APP_BMEM bool connected;

#if defined(CONFIG_MQTT_LIB_TLS)

#define SERVER_PORT SERVER_PORT_TLS
#include "cert.h"

#define TLS_SNI_HOSTNAME "test.mosquitto.org"
#define APP_CA_CERT_TAG 1
#define APP_PSK_TAG 2

static APP_DMEM sec_tag_t m_sec_tags[] = {
#if defined(MBEDTLS_X509_CRT_PARSE_C) || defined(CONFIG_NET_SOCKETS_OFFLOAD)
        APP_CA_CERT_TAG,
#endif
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
        APP_PSK_TAG,
#endif
};

static int tls_init(void)
{
    int err = -EINVAL;

#if defined(MBEDTLS_X509_CRT_PARSE_C) || defined(CONFIG_NET_SOCKETS_OFFLOAD)
    err = tls_credential_add(APP_CA_CERT_TAG, TLS_CREDENTIAL_CA_CERTIFICATE,
                 ca_certificate, sizeof(ca_certificate));

    if (err < 0) {
        LOG_ERR("Failed to register public certificate: %d", err);
            printk("sono quin");
        return err;
    }
#endif

#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
    err = tls_credential_add(APP_PSK_TAG, TLS_CREDENTIAL_PSK,
                 client_psk, sizeof(client_psk));
    if (err < 0) {
        LOG_ERR("Failed to register PSK: %d", err);
        return err;
    }

    err = tls_credential_add(APP_PSK_TAG, TLS_CREDENTIAL_PSK_ID,
                 client_psk_id, sizeof(client_psk_id) - 1);
    if (err < 0) {
        LOG_ERR("Failed to register PSK ID: %d", err);
    }
#endif

    return err;
}

#endif /* CONFIG_MQTT_LIB_TLS */

static void prepare_fds(struct mqtt_client *client)
{
    if (client->transport.type == MQTT_TRANSPORT_NON_SECURE) {
        fds[0].fd = client->transport.tcp.sock;
    }
#if defined(CONFIG_MQTT_LIB_TLS)
    else if (client->transport.type == MQTT_TRANSPORT_SECURE) {
        fds[0].fd = client->transport.tls.sock;
    }
#endif

    fds[0].events = POLLIN;
    nfds = 1;
}

static void clear_fds(void)
{
    nfds = 0;
}

static int wait(int timeout)
{
    int ret = 0;

    if (nfds > 0) {
        ret = poll(fds, nfds, timeout);
        if (ret < 0) {
            LOG_ERR("poll error: %d", errno);
        }
    }

    return ret;
}

// added code for mqtt subscriber

static void on_mqtt_publish(struct mqtt_client *const client, const struct mqtt_evt *evt)
{
    int rc;
    uint8_t payload[APP_MQTT_BUFFER_SIZE];

    rc = mqtt_read_publish_payload(client, payload,
                    APP_MQTT_BUFFER_SIZE);
    if (rc < 0) {
        LOG_ERR("Failed to read received MQTT payload [%d]", rc);
        return;
    }
    /* Place null terminator at end of payload buffer */
    payload[rc] = '';
    
    printk("MQTT payload received!n");
    LOG_INF("MQTT payload received!");
    printk("topic: '%s', payload: %sn",
        evt->param.publish.message.topic.topic.utf8, payload);

    // /* If the topic is a command, call the command handler  */
    // if (strcmp(evt->param.publish.message.topic.topic.utf8,
    //      MQTT_TOPIC) == 0) {
    //  device_command_handler(payload);
    // }
}

int app_mqtt_subscribe(struct mqtt_client *client)
{
    int rc;
    struct mqtt_topic sub_topics[] = {
        {
            .topic = {
                .utf8 = MQTT_TOPIC,
                .size = strlen(sub_topics->topic.utf8)
            },
            .qos = IS_ENABLED(CONFIG_NET_SAMPLE_MQTT_QOS_0_AT_MOST_ONCE) ? 0 :
                (IS_ENABLED(CONFIG_NET_SAMPLE_MQTT_QOS_1_AT_LEAST_ONCE) ? 1 : 2)
        }
    };
    const struct mqtt_subscription_list sub_list = {
        .list = sub_topics,
        .list_count = ARRAY_SIZE(sub_topics),
        .message_id = 5841u
    };

    LOG_INF("Subscribing to %d topic(s)", sub_list.list_count);

    rc = mqtt_subscribe(client, &sub_list);
    if (rc != 0) {
        LOG_ERR("MQTT Subscribe failed [%d]", rc);
    }
    else
    {
        LOG_INF("MQTT Subscribe success [%d]", rc);
    }

    return rc;
}

// end code for mqtt subscriber

void mqtt_evt_handler(struct mqtt_client *const client,
              const struct mqtt_evt *evt)
{
    int err;

    switch (evt->type) {
    case MQTT_EVT_CONNACK:
        if (evt->result != 0) {
            LOG_ERR("MQTT connect failed %d", evt->result);
            break;
        }

        connected = true;
        LOG_INF("MQTT client connected!");

        app_mqtt_subscribe(client);

        break;

    case MQTT_EVT_DISCONNECT:
        LOG_INF("MQTT client disconnected %d", evt->result);

        connected = false;
        clear_fds();

        break;

    case MQTT_EVT_PUBACK:
        if (evt->result != 0) {
            LOG_ERR("MQTT PUBACK error %d", evt->result);
            break;
        }

        LOG_INF("PUBACK packet id: %u", evt->param.puback.message_id);

        break;

    case MQTT_EVT_SUBACK:  // Add this case to handle subscription acknowledgment
        if (evt->result != 0) {
            LOG_ERR("MQTT SUBACK error %d", evt->result);
            break;
        }
        LOG_INF("Subscription acknowledged, id: %u", evt->param.suback.message_id);

    break;
        
    case MQTT_EVT_PUBREC:
        if (evt->result != 0) {
            LOG_ERR("MQTT PUBREC error %d", evt->result);
            break;
        }

        LOG_INF("PUBREC packet id: %u", evt->param.pubrec.message_id);

        const struct mqtt_pubrel_param rel_param = {
            .message_id = evt->param.pubrec.message_id
        };

        err = mqtt_publish_qos2_release(client, &rel_param);
        if (err != 0) {
            LOG_ERR("Failed to send MQTT PUBREL: %d", err);
        }

        break;

    case MQTT_EVT_PUBREL:                                       // non presente in mqtt_publisher
        if (evt->result != 0) {                                 // serve per QoS2
            LOG_ERR("MQTT PUBREL error [%d]", evt->result);
            break;
        }

        LOG_INF("PUBREL packet ID: %u", evt->param.pubrel.message_id);

        const struct mqtt_pubcomp_param rec_param = {
            .message_id = evt->param.pubrel.message_id
        };

        mqtt_publish_qos2_complete(client, &rec_param);
        break;

    case MQTT_EVT_PUBCOMP:
        if (evt->result != 0) {
            LOG_ERR("MQTT PUBCOMP error %d", evt->result);
            break;
        }

        LOG_INF("PUBCOMP packet id: %u",
            evt->param.pubcomp.message_id);

        break;

    case MQTT_EVT_PINGRESP:
        LOG_INF("PINGRESP packet");
        break;

    case MQTT_EVT_PUBLISH:                                              // non presente in mqtt_publisher
        const struct mqtt_publish_param *p = &evt->param.publish;       // serve per pubblicare messaggi su un topic a cui il client è sottoscritto

        if (p->message.topic.qos == MQTT_QOS_1_AT_LEAST_ONCE) {
            const struct mqtt_puback_param ack_param = {
                .message_id = p->message_id
            };
            mqtt_publish_qos1_ack(client, &ack_param);
        } else if (p->message.topic.qos == MQTT_QOS_2_EXACTLY_ONCE) {
            const struct mqtt_pubrec_param rec_param = {
                .message_id = p->message_id
            };
            mqtt_publish_qos2_receive(client, &rec_param);
        }

        on_mqtt_publish(client, evt);

    default:
        break;
    }
}

static char *get_mqtt_payload(enum mqtt_qos qos)
{
#if APP_BLUEMIX_TOPIC
    static APP_BMEM char payload[30];

    snprintk(payload, sizeof(payload), "{d:{temperature:%d}}",
         sys_rand8_get());
#else
    static APP_DMEM char payload[] = "DOORS:OPEN_QoSx";

    payload[strlen(payload) - 1] = '0' + qos;
#endif

    return payload;
}

static char *get_mqtt_topic(void)
{
#if APP_BLUEMIX_TOPIC
    return "iot-2/type/"BLUEMIX_DEVTYPE"/id/"BLUEMIX_DEVID
           "/evt/"BLUEMIX_EVENT"/fmt/"BLUEMIX_FORMAT;
#else
    return "testtopic/federzep";
#endif
}

static int publish(struct mqtt_client *client, enum mqtt_qos qos)
{
    struct mqtt_publish_param param;

    param.message.topic.qos = qos;
    param.message.topic.topic.utf8 = (uint8_t *)get_mqtt_topic();
    param.message.topic.topic.size =
            strlen(param.message.topic.topic.utf8);
    param.message.payload.data = get_mqtt_payload(qos);
    param.message.payload.len =
            strlen(param.message.payload.data);
    param.message_id = sys_rand16_get();
    param.dup_flag = 0U;
    param.retain_flag = 0U;

    return mqtt_publish(client, &param);
}

#define RC_STR(rc) ((rc) == 0 ? "OK" : "ERROR")

#define PRINT_RESULT(func, rc) 
    LOG_INF("%s: %d <%s>", (func), rc, RC_STR(rc));

static void broker_init(void)
{
#if defined(CONFIG_NET_IPV6)
    struct sockaddr_in6 *broker6 = (struct sockaddr_in6 *)&broker;

    broker6->sin6_family = AF_INET6;
    broker6->sin6_port = htons(SERVER_PORT);
    inet_pton(AF_INET6, SERVER_ADDR, &broker6->sin6_addr);

#if defined(CONFIG_SOCKS)
    struct sockaddr_in6 *proxy6 = (struct sockaddr_in6 *)&socks5_proxy;

    proxy6->sin6_family = AF_INET6;
    proxy6->sin6_port = htons(SOCKS5_PROXY_PORT);
    inet_pton(AF_INET6, SOCKS5_PROXY_ADDR, &proxy6->sin6_addr);
#endif
#else
    struct sockaddr_in *broker4 = (struct sockaddr_in *)&broker;

    broker4->sin_family = AF_INET;
    broker4->sin_port = htons(SERVER_PORT);
    inet_pton(AF_INET, SERVER_ADDR, &broker4->sin_addr);
#if defined(CONFIG_SOCKS)
    struct sockaddr_in *proxy4 = (struct sockaddr_in *)&socks5_proxy;
    #define SOCKS5_PROXY_PORT 1080  // Replace with your actual SOCKS5 proxy port
    proxy4->sin_family = AF_INET;
    proxy4->sin_port = htons(SOCKS5_PROXY_PORT);
    inet_pton(AF_INET, SOCKS5_PROXY_ADDR, &proxy4->sin_addr);
#endif
#endif
}

static void client_init(struct mqtt_client *client)
{
    mqtt_client_init(client);
    // printk("mqtt_client_init testn");
    broker_init();
    // printk("broker_init testn");
    /* MQTT client configuration */
    client->broker = &broker;
    client->evt_cb = mqtt_evt_handler;
    client->client_id.utf8 = (uint8_t *)MQTT_CLIENTID;
    client->client_id.size = strlen(MQTT_CLIENTID);
    client->password = MQTT_PASS /*NULL*/;
    client->user_name = MQTT_USER /*NULL*/;
    client->protocol_version = MQTT_VERSION_3_1_1;

    /* MQTT buffers configuration */
    client->rx_buf = rx_buffer;
    client->rx_buf_size = sizeof(rx_buffer);
    client->tx_buf = tx_buffer;
    client->tx_buf_size = sizeof(tx_buffer);

    /* MQTT transport configuration */
#if defined(CONFIG_MQTT_LIB_TLS)
#if defined(CONFIG_MQTT_LIB_WEBSOCKET)
    client->transport.type = MQTT_TRANSPORT_SECURE_WEBSOCKET;
#else
    client->transport.type = MQTT_TRANSPORT_SECURE;
#endif

    struct mqtt_sec_config *tls_config = &client->transport.tls.config;

    tls_config->peer_verify = TLS_PEER_VERIFY_REQUIRED;
    tls_config->cipher_list = NULL;
    tls_config->sec_tag_list = m_sec_tags;
    tls_config->sec_tag_count = ARRAY_SIZE(m_sec_tags);
#if defined(MBEDTLS_X509_CRT_PARSE_C) || defined(CONFIG_NET_SOCKETS_OFFLOAD)
    tls_config->hostname = TLS_SNI_HOSTNAME;
#else
    tls_config->hostname = NULL;
#endif

#else
#if defined(CONFIG_MQTT_LIB_WEBSOCKET)
    client->transport.type = MQTT_TRANSPORT_NON_SECURE_WEBSOCKET;
#else
    client->transport.type = MQTT_TRANSPORT_NON_SECURE;
#endif
#endif

#if defined(CONFIG_MQTT_LIB_WEBSOCKET)
    client->transport.websocket.config.host = SERVER_ADDR;
    client->transport.websocket.config.url = "/mqtt";
    client->transport.websocket.config.tmp_buf = temp_ws_rx_buf;
    client->transport.websocket.config.tmp_buf_len =
                        sizeof(temp_ws_rx_buf);
    client->transport.websocket.timeout = 50 * MSEC_PER_SEC;
#endif

#if defined(CONFIG_SOCKS)
    mqtt_client_set_proxy(client, &socks5_proxy,
                  socks5_proxy.sa_family == AF_INET ?
                  sizeof(struct sockaddr_in) :
                  sizeof(struct sockaddr_in6));
#endif
}

/* Subscribe to a topic */
// static void subscribe_topic(struct mqtt_client *client)
// {
//     struct mqtt_topic topic = {
//         .topic = {
//             .utf8 = (uint8_t *)"testtopic/federzep",
//             .size = strlen("testtopic/federzep")
//         },
//         .qos = MQTT_QOS_1_AT_LEAST_ONCE,
//     };

//     struct mqtt_subscription_list subs = {
//         .list = &topic,
//         .list_count = 1,
//         .message_id = sys_rand32_get(),
//     };

//     int ret = mqtt_subscribe(client, &subs);
//     if (ret) {
//         LOG_ERR("Failed to subscribe to topic (err %d)", ret);
//     } else {
//         LOG_INF("Subscription request sent");
//     }
// }

/* In this routine we block until the connected variable is 1 */
static int try_to_connect(struct mqtt_client *client)
{
    int rc, i = 0;
    // printk("0tn");
    while (i++ < APP_CONNECT_TRIES && !connected) {

        client_init(client);
        // printk("client_init testn");
        rc = mqtt_connect(client);
        // printk("mqtt_connect testn");
        if (rc != 0) {
            PRINT_RESULT("mqtt_connect", rc);
            k_sleep(K_MSEC(APP_SLEEP_MSECS));
            continue;
        }

        prepare_fds(client);

        if (wait(APP_CONNECT_TIMEOUT_MS)) {
            mqtt_input(client);
        }

        if (!connected) {
            mqtt_abort(client);
            printk("Disconnected from mqtt");
        }
    }

    if (connected) {
        return 0;
    }

    return -EINVAL;
}

static int process_mqtt_and_sleep(struct mqtt_client *client, int timeout)
{
    int64_t remaining = timeout;
    int64_t start_time = k_uptime_get();
    int rc;
    // printk(" valore connected %d n",connected);
    while (remaining > 0 && connected) {
        if (wait(remaining)) {
            rc = mqtt_input(client);
            if (rc != 0) {
                PRINT_RESULT("mqtt_input", rc);
                return rc;
            }
        }

        rc = mqtt_live(client);
        if (rc != 0 && rc != -EAGAIN) {
            PRINT_RESULT("mqtt_live", rc);
            return rc;
        } else if (rc == 0) {
            rc = mqtt_input(client);
            if (rc != 0) {
                PRINT_RESULT("mqtt_input", rc);
                return rc;
            }
        }

        remaining = timeout + start_time - k_uptime_get();
    }

    return 0;
}

#define SUCCESS_OR_EXIT(rc) { if (rc != 0) { return 1; } }
#define SUCCESS_OR_BREAK(rc) { if (rc != 0) { break; } }

static int publisher(void)
{
    int i, rc, r = 0;
    // printk("0pn");
    LOG_INF("attempting to connect: ");
    rc = try_to_connect(&client_ctx);
    PRINT_RESULT("try_to_connect", rc);
    SUCCESS_OR_EXIT(rc);
    // printk("i'm out of whilen");
    i = 0;
    k_msleep(5000);
    while (i++ < CONFIG_NET_SAMPLE_APP_MAX_ITERATIONS && connected) {
        r = -1;

        rc = mqtt_ping(&client_ctx);
        PRINT_RESULT("mqtt_ping", rc);
        SUCCESS_OR_BREAK(rc);
        // printk("i'm here in the while");
        rc = process_mqtt_and_sleep(&client_ctx, APP_CONNECT_TIMEOUT_MS);
        SUCCESS_OR_BREAK(rc);

        rc = publish(&client_ctx, MQTT_QOS_0_AT_MOST_ONCE);
        PRINT_RESULT("mqtt_publish", rc);
        SUCCESS_OR_BREAK(rc);

        rc = process_mqtt_and_sleep(&client_ctx, APP_CONNECT_TIMEOUT_MS);
        SUCCESS_OR_BREAK(rc);

        rc = publish(&client_ctx, MQTT_QOS_1_AT_LEAST_ONCE);
        PRINT_RESULT("mqtt_publish", rc);
        SUCCESS_OR_BREAK(rc);

        rc = process_mqtt_and_sleep(&client_ctx, APP_CONNECT_TIMEOUT_MS);
        SUCCESS_OR_BREAK(rc);

        rc = publish(&client_ctx, MQTT_QOS_2_EXACTLY_ONCE);
        PRINT_RESULT("mqtt_publish", rc);
        SUCCESS_OR_BREAK(rc);

        rc = process_mqtt_and_sleep(&client_ctx, APP_CONNECT_TIMEOUT_MS);
        SUCCESS_OR_BREAK(rc);

        r = 0;
    }

    rc = mqtt_disconnect(&client_ctx);
    PRINT_RESULT("mqtt_disconnect", rc);

    LOG_INF("Bye!");

    return r;
}

static int start_app(void)
{
    int r = 0, i = 0;
    
    // printk("0sn");

    while (!CONFIG_NET_SAMPLE_APP_MAX_CONNECTIONS ||
           i++ < CONFIG_NET_SAMPLE_APP_MAX_CONNECTIONS) {
        r = publisher();

        if (!CONFIG_NET_SAMPLE_APP_MAX_CONNECTIONS) {
            k_sleep(K_MSEC(5000));
        }
    }
    // printk("0sn");
    return r;
}

#if defined(CONFIG_USERSPACE)
#define STACK_SIZE 2048

#if defined(CONFIG_NET_TC_THREAD_COOPERATIVE)
#define THREAD_PRIORITY K_PRIO_COOP(CONFIG_NUM_COOP_PRIORITIES - 1)
#else
#define THREAD_PRIORITY K_PRIO_PREEMPT(8)
#endif

K_THREAD_DEFINE(app_thread, STACK_SIZE,
        start_app, NULL, NULL, NULL,
        THREAD_PRIORITY, K_USER, -1);

static K_HEAP_DEFINE(app_mem_pool, 1024 * 2);
#endif

// added code for wifi connection

static void handle_wifi_connect_result(struct net_mgmt_event_callback *cb)
{
    const struct wifi_status *status = (const struct wifi_status *)cb->info;

    if (status->status)
    {
        printk("Connection request failed (%d)n", status->status);
    }
    else
    {
        printk("Connected (%lld)n", k_uptime_get());
        k_sem_give(&wifi_connected);
    }
}

static void handle_wifi_disconnect_result(struct net_mgmt_event_callback *cb)
{
    const struct wifi_status *status = (const struct wifi_status *)cb->info;

    if (status->status)
    {
        printk("Disconnection request (%d)n", status->status);
    }
    else
    {
        printk("Disconnected (%lld)n", k_uptime_get());
        k_sem_take(&wifi_connected, K_NO_WAIT);
    }
}

static void handle_ipv4_result(struct net_if *iface)
{
    int i = 0;

    for (i = 0; i < NET_IF_MAX_IPV4_ADDR; i++) {

        char buf[NET_IPV4_ADDR_LEN];

        printk("IPv4 address: %sn",
                net_addr_ntop(AF_INET,
                                &iface->config.ip.ipv4->unicast[i].ipv4,
                                buf, sizeof(buf)));
        printk("Subnet: %sn",
                net_addr_ntop(AF_INET,
                                &iface->config.ip.ipv4->unicast[i].netmask,
                                buf, sizeof(buf)));
        printk("Router: %sn",
                net_addr_ntop(AF_INET,
                                &iface->config.ip.ipv4->gw,
                                buf, sizeof(buf)));
        }

        k_sem_give(&ipv4_address_obtained);
}

static void wifi_mgmt_event_handler(struct net_mgmt_event_callback *cb, uint32_t mgmt_event, struct net_if *iface)
{
    switch (mgmt_event)
    {

        case NET_EVENT_WIFI_CONNECT_RESULT:
            handle_wifi_connect_result(cb);
            break;

        case NET_EVENT_WIFI_DISCONNECT_RESULT:
            handle_wifi_disconnect_result(cb);
            break;

        case NET_EVENT_IPV4_ADDR_ADD:
            handle_ipv4_result(iface);
            break;

        default:
            break;
    }
}

void wifi_connect(void)
{
    struct net_if *iface = net_if_get_default();

    struct wifi_connect_req_params wifi_params = {0};

    wifi_params.ssid = SSID;
    wifi_params.psk = PSK;
    wifi_params.ssid_length = strlen(SSID);
    wifi_params.psk_length = strlen(PSK);
    wifi_params.channel = WIFI_CHANNEL_ANY;
    wifi_params.security = WIFI_SECURITY_TYPE_PSK;
    wifi_params.band = WIFI_FREQ_BAND_2_4_GHZ; 
    wifi_params.mfp = WIFI_MFP_OPTIONAL;

    printk("Connecting to SSID: %sn", wifi_params.ssid);

    if (net_mgmt(NET_REQUEST_WIFI_CONNECT, iface, &wifi_params, sizeof(struct wifi_connect_req_params)))
    {
        printk("WiFi Connection Request Failedn");
    }
}

void wifi_status(void)
{
    struct net_if *iface = net_if_get_default();
    
    struct wifi_iface_status status = {0};

    if (net_mgmt(NET_REQUEST_WIFI_IFACE_STATUS, iface, &status, sizeof(struct wifi_iface_status)))
    {
        printk("WiFi Status Request Failedn");
    }

    printk("n");

    if (status.state >= WIFI_STATE_ASSOCIATED) {
        printk("SSID: %-32sn", status.ssid);
        printk("Band: %sn", wifi_band_txt(status.band));
        printk("Channel: %dn", status.channel);
        printk("Security: %sn", wifi_security_txt(status.security));
        printk("RSSI: %dn", status.rssi);
    }
}

void wifi_disconnect(void)
{
    struct net_if *iface = net_if_get_default();

    if (net_mgmt(NET_REQUEST_WIFI_DISCONNECT, iface, NULL, 0))
    {
        printk("WiFi Disconnection Request Failedn");
    }
}

// end code for wifi connection

int main(void)
{
    printk("WiFi ExamplenBoard: %sn", CONFIG_BOARD);

    net_mgmt_init_event_callback(&wifi_cb, wifi_mgmt_event_handler,
                                 NET_EVENT_WIFI_CONNECT_RESULT | NET_EVENT_WIFI_DISCONNECT_RESULT);

    net_mgmt_init_event_callback(&ipv4_cb, wifi_mgmt_event_handler, NET_EVENT_IPV4_ADDR_ADD);

    net_mgmt_add_event_callback(&wifi_cb);
    net_mgmt_add_event_callback(&ipv4_cb);

    wifi_connect();
    k_sem_take(&wifi_connected, K_FOREVER);
    wifi_status();
    k_sem_take(&ipv4_address_obtained, K_FOREVER);
    printk("Ready...nn");


#if defined(CONFIG_MQTT_LIB_TLS)
    int rc;
    // printk("0xn");
    rc = tls_init();
    PRINT_RESULT("tls_init", rc);
#endif

#if defined(CONFIG_USERSPACE)

    int ret;
    // printk("0xn");
    struct k_mem_partition *parts[] = {
#if Z_LIBC_PARTITION_EXISTS
        &z_libc_partition,
#endif
        &app_partition
    };

    ret = k_mem_domain_init(&app_domain, ARRAY_SIZE(parts), parts);
    __ASSERT(ret == 0, "k_mem_domain_init() failed %d", ret);
    ARG_UNUSED(ret);
    // printk("0yn");
    k_mem_domain_add_thread(&app_domain, app_thread);
    k_thread_heap_assign(app_thread, &app_mem_pool);

    // printk("0yn");

    k_thread_start(app_thread);
    k_thread_join(app_thread, K_FOREVER);
#else
    exit(start_app());
#endif
    return 0;
}

While this is the prj.conf:

CONFIG_WIFI=y
CONFIG_INIT_STACKS=y
CONFIG_NET_L2_WIFI_MGMT=y

CONFIG_NETWORKING=y     
CONFIG_NET_SOCKETS=y       
CONFIG_NET_TCP=y        
CONFIG_NET_LOG=y
CONFIG_NET_SOCKETS_OFFLOAD=y
CONFIG_MDNS_RESOLVER=y

# CONFIG_NET_IPV6_RA_RDNSS=y
# CONFIG_NET_IF_UNICAST_IPV6_ADDR_COUNT=3
# CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT=2

CONFIG_ESP32_WIFI_STA_AUTO_DHCPV4=y
CONFIG_ESP32_WIFI_STA_RECONNECT=y

CONFIG_PRINTK=y         
CONFIG_STDOUT_CONSOLE=y 
CONFIG_POSIX_API=y      

# Enable IPv6 support
CONFIG_NET_IPV6=n       
# Enable IPv4 support
CONFIG_NET_IPV4=y       

CONFIG_NET_UDP=y
CONFIG_DNS_RESOLVER=n
CONFIG_DNS_RESOLVER_AI_MAX_ENTRIES=10

CONFIG_HTTP_CLIENT=y

# Use DHCP for IPv4
CONFIG_NET_DHCPV4=y

# Enable the MQTT Lib
CONFIG_MQTT_LIB=y    
CONFIG_MQTT_LIB_TLS=y

CONFIG_NET_CONFIG_SETTINGS=y                            
# CONFIG_NET_CONFIG_MY_IPV6_ADDR="2001:db8::1"
# CONFIG_NET_CONFIG_PEER_IPV6_ADDR="2001:db8::2"

# CONFIG_NET_CONFIG_MY_IPV4_ADDR="192.168.218.28"
# CONFIG_NET_CONFIG_PEER_IPV4_ADDR="192.168.218.200"

CONFIG_MAIN_STACK_SIZE=2048                             

CONFIG_NET_CONFIG_INIT_TIMEOUT=1

CONFIG_TLS_CREDENTIALS=y

CONFIG_NET_SOCKETS_SOCKOPT_TLS=y

# Enable Mbed TLS       error when enabled
CONFIG_MBEDTLS=y
CONFIG_MBEDTLS_BUILTIN=y
CONFIG_MBEDTLS_ENABLE_HEAP=y
CONFIG_MBEDTLS_HEAP_SIZE=30000
CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=2048
CONFIG_MBEDTLS_PEM_CERTIFICATE_FORMAT=n
CONFIG_MBEDTLS_SERVER_NAME_INDICATION=n

CONFIG_NET_TX_STACK_SIZE=2048
CONFIG_NET_RX_STACK_SIZE=2048

CONFIG_NET_PKT_RX_COUNT=10
CONFIG_NET_PKT_TX_COUNT=10

CONFIG_NET_BUF_RX_COUNT=20
CONFIG_NET_BUF_TX_COUNT=20

CONFIG_NET_MAX_CONTEXTS=10

# For IPv6
CONFIG_NET_BUF_DATA_SIZE=256            

CONFIG_NET_SHELL=y    
CONFIG_NET_L2_WIFI_SHELL=y                  

CONFIG_ENTROPY_GENERATOR=y              
CONFIG_TEST_RANDOM_GENERATOR=y          

CONFIG_NET_L2_ETHERNET=y

CONFIG_PRINTK_BUFFER_SIZE=2048

And this is the config.h file with the IP and ports:

#ifndef __CONFIG_H__
#define __CONFIG_H__

// #define SERVER_HOSTNAME      "broker.emqx.io" /*MQTT Hostname*/
// #define SERVER_ADDR      "35.172.255.228"            // broker.emqx.io
#define SERVER_HOSTNAME     "test.mosquitto.org"
#define SERVER_ADDR     "5.196.78.28"             // test.mosquitto.org
// #define SERVER_HOSTNAME      "localhost"
// #define SERVER_ADDR      ""            // localhost
// #define SERVER_HOSTNAME      "c666792db5ef42e5b9da3c1285f20daf"
// #define SERVER_ADDR      ""            // HiveMQ
#define SERVER_PORT             1883
#define SERVER_PORT_TLS         8883
#define MQTT_TOPIC      "testtopic/federzep"
#define MQTT_USER       /*NULL*/     "admin-user"
#define MQTT_PASS       /*NULL*/     "admin-password"

#define APP_CONNECT_TIMEOUT_MS  2000
#define APP_SLEEP_MSECS     500

#define APP_CONNECT_TRIES   3

#define APP_MQTT_BUFFER_SIZE    128

#define MQTT_CLIENTID       "zephyr_publisher"

#endif

This is the ca_certificate as it was given by zephyr (cert.h file) and which i haven’t modified:

static const unsigned char ca_certificate[] = {"-----BEGIN CERTIFICATE-----rn
MIIEAzCCAuugAwIBAgIUBY1hlCGvdj4NhBXkZ/uLUZNILAwwDQYJKoZIhvcNAQELrn
BQAwgZAxCzAJBgNVBAYTAkdCMRcwFQYDVQQIDA5Vbml0ZWQgS2luZ2RvbTEOMAwGrn
A1UEBwwFRGVyYnkxEjAQBgNVBAoMCU1vc3F1aXR0bzELMAkGA1UECwwCQ0ExFjAUrn
BgNVBAMMDW1vc3F1aXR0by5vcmcxHzAdBgkqhkiG9w0BCQEWEHJvZ2VyQGF0Y2hvrn
by5vcmcwHhcNMjAwNjA5MTEwNjM5WhcNMzAwNjA3MTEwNjM5WjCBkDELMAkGA1UErn
BhMCR0IxFzAVBgNVBAgMDlVuaXRlZCBLaW5nZG9tMQ4wDAYDVQQHDAVEZXJieTESrn
MBAGA1UECgwJTW9zcXVpdHRvMQswCQYDVQQLDAJDQTEWMBQGA1UEAwwNbW9zcXVprn
dHRvLm9yZzEfMB0GCSqGSIb3DQEJARYQcm9nZXJAYXRjaG9vLm9yZzCCASIwDQYJrn
KoZIhvcNAQEBBQADggEPADCCAQoCggEBAME0HKmIzfTOwkKLT3THHe+ObdizamPgrn
UZmD64Tf3zJdNeYGYn4CEXbyP6fy3tWc8S2boW6dzrH8SdFf9uo320GJA9B7U1FWrn
Te3xda/Lm3JFfaHjkWw7jBwcauQZjpGINHapHRlpiCZsquAthOgxW9SgDgYlGzEArn
s06pkEFiMw+qDfLo/sxFKB6vQlFekMeCymjLCbNwPJyqyhFmPWwio/PDMruBTzPHrn
3cioBnrJWKXc3OjXdLGFJOfj7pP0j/dr2LH72eSvv3PQQFl90CZPFhrCUcRHSSxorn
E6yjGOdnz7f6PveLIB574kQORwt8ePn0yidrTC1ictikED3nHYhMUOUCAwEAAaNTrn
MFEwHQYDVR0OBBYEFPVV6xBUFPiGKDyo5V3+Hbh4N9YSMB8GA1UdIwQYMBaAFPVVrn
6xBUFPiGKDyo5V3+Hbh4N9YSMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELrn
BQADggEBAGa9kS21N70ThM6/Hj9D7mbVxKLBjVWe2TPsGfbl3rEDfZ+OKRZ2j6ACrn
6r7jb4TZO3dzF2p6dgbrlU71Y/4K0TdzIjRj3cQ3KSm41JvUQ0hZ/c04iGDg/xWfrn
+pp58nfPAYwuerruPNWmlStWAXf0UTqRtg4hQDWBuUFDJTuWuuBvEXudz74eh/wKrn
sMwfu1HFvjy5Z0iMDU8PUDepjVolOCue9ashlS4EB5IECdSR2TItnAIiIwimx839rn
LdUdRudafMu5T5Xma182OC0/u/xRlEm+tvKGGmfFcN0piqVl8OrSPBgIlb+1IKJErn
m/XriWr/Cq4h/JfB7NTsezVslgkBaoU=rn
-----END CERTIFICATE-----rn"};

It worked with TLS connection disable but when I add the TLS configuration the following error appears:

[00:00:26.326,000] <inf> net_mqtt_publisher_sample: tls_init: 0 <OK>
[00:00:26.326,000] <inf> net_mqtt_publisher_sample: attempting to connect: 
[00:00:26.401,000] <err> net_sock_tls: Failed to parse CA certificate, err: -0x2180
[00:00:26.402,000] <inf> net_mqtt_publisher_sample: mqtt_connect: -22 <ERROR>
[00:00:26.957,000] <err> net_sock_tls: Failed to parse CA certificate, err: -0x2180
[00:00:26.959,000] <inf> net_mqtt_publisher_sample: mqtt_connect: -22 <ERROR>
[00:00:27.520,000] <err> net_sock_tls: Failed to parse CA certificate, err: -0x2180
[00:00:27.521,000] <inf> net_mqtt_publisher_sample: mqtt_connect: -22 <ERROR>
[00:00:28.021,000] <inf> net_mqtt_publisher_sample: try_to_connect: -22 <ERROR>

I’m trying the access with the username and password.
I have tried to change the broker (test.mosquitto.org and a local HiveMQ broker) and the respective certificate.
I will add that on MQTTX it connects correctly to both so the brokers should not be the problem.