I am developing an MQTT client application with NRF9160, trying to connect to a Mosquitto broker using TLS with three certificates. However, I am encountering an SSL version error while attempting to establish the connection. Below are the error messages:
ON NRF9160 SIDE:
Disconnecting MQTT client...+CSCON: 0
[00:03:06.727,081] <err> mqtt_simple: ERROR: mqtt_live: -128
[00:03:06.729,705] <err> mqtt_simple: Could not disconnect MQTT client: -128
[00:03:06.729,705] <inf> mqtt_simple: Reconnecting in 60 seconds...
ON BROKER SIDE:
1721805881: New connection from 10.10.104.103 on port 9502.
1721805881: OpenSSL Error[0]: error:1408F10B:SSL routines:ssl3_get_record:wrong version number
1721805881: Socket error on client <unknown>, disconnecting.
-----------------------------PROJECT CONF:
#
# Copyright (c) 2020 Nordic Semiconductor ASA
#
# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
#
# Networking
CONFIG_NRF_MODEM_LIB_SYS_INIT=y
CONFIG_NETWORKING=y
CONFIG_NET_NATIVE=n
CONFIG_NET_SOCKETS_OFFLOAD=y
CONFIG_NET_SOCKETS=y
CONFIG_NET_SOCKETS_POSIX_NAMES=y
# LTE link control
CONFIG_LTE_LINK_CONTROL=y
CONFIG_LTE_AUTO_INIT_AND_CONNECT=n
# Modem library
CONFIG_NRF_MODEM_LIB=y
# AT Host
CONFIG_UART_INTERRUPT_DRIVEN=y
CONFIG_AT_HOST_LIBRARY=y
# MQTT
CONFIG_MQTT_LIB=y
CONFIG_MQTT_LIB_TLS=y
CONFIG_MQTT_CLEAN_SESSION=y
CONFIG_MBEDTLS_BUILTIN=y
CONFIG_MBEDTLS=y
CONFIG_NET_SOCKETS_SOCKOPT_TLS=y
CONFIG_TLS_CREDENTIALS=y
# Application
CONFIG_MQTT_PUB_TOPIC="acrux/my/publish/topic"
# CONFIG_MQTT_SUB_TOPIC="my/subscribe/topic"
# CONFIG_MQTT_CLIENT_ID="my-client-id"
#CONFIG_MQTT_BROKER_HOSTNAME="mqtt.eclipseprojects.io"
CONFIG_MQTT_BROKER_HOSTNAME="3.125.121.252" #Hivemq Public Broker
CONFIG_MQTT_BROKER_PORT=1883
CONFIG_LTE_NETWORK_MODE_LTE_M=n
CONFIG_LTE_NETWORK_MODE_NBIOT=y
# Button support
CONFIG_DK_LIBRARY=y
# Enable logging
CONFIG_LOG=y
CONFIG_MQTT_SIMPLE_LOG_LEVEL_DBG=y
CONFIG_THREAD_NAME=y
# Memory
CONFIG_NET_RX_STACK_SIZE=2520
CONFIG_NET_TX_STACK_SIZE=2520
CONFIG_MAIN_STACK_SIZE=64000
CONFIG_HEAP_MEM_POOL_SIZE=32600
CONFIG_NET_BUF_DATA_SIZE=2520
CONFIG_NET_BUF_USER_DATA_SIZE=2520
CONFIG_NRF_MODEM_LIB_SHMEM_TX_SIZE=4096
CONFIG_MQTT_MESSAGE_BUFFER_SIZE=2048
CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=32600
CONFIG_IDLE_STACK_SIZE=8192
CONFIG_MQTT_PAYLOAD_BUFFER_SIZE=4096
# NewLib C
CONFIG_NEWLIB_LIBC=y
CONFIG_PDN=y
CONFIG_PDN_DEFAULTS_OVERRIDE=y
CONFIG_PDN_SYS_INIT=y
# Note: "ip" is set by PDN_DEFAULT_FAM kconfig's
# example:
# AT+CGDCONT=1,"ip","apn" - below only sets APN field
CONFIG_PDN_DEFAULT_APN="nbiot"
CONFIG_DATE_TIME=y
CONFIG_DATE_TIME_UPDATE_INTERVAL_SECONDS=1
CONFIG_DATE_TIME_NTP=n
CONFIG_DATE_TIME_MODEM=y
CONFIG_NEWLIB_LIBC_NANO=n
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
#include <drivers/uart.h>
#include <inttypes.h>
#include <logging/log.h>
#include <mbedtls/ssl.h>
#include <modem/at_cmd.h>
#include <modem/lte_lc.h>
#include <net/mqtt.h>
#include <net/socket.h>
#include <net/tls_credentials.h>
#include <random/rand32.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <zephyr.h>
#if defined(CONFIG_MODEM_KEY_MGMT)
#include <modem/modem_key_mgmt.h>
#endif
#if defined(CONFIG_LWM2M_CARRIER)
#include <lwm2m_carrier.h>
#endif
#include <dk_buttons_and_leds.h>
#include "certificates.h"
#include <date_time.h>
// Sertifika ve anahtar içerikleri
static const char ca_cert[] = "-----BEGIN CERTIFICATE-----\nMIIDkjCCAnqgAwIBAgIUdoorrAMq0T7FmgGORIrjmKqzrsYwDQYJKoZIhvcNAQEL\nBQAwaTELMAkGA1UEBhMCVFIxDzANBgNVBAgMBkFua2FyYTEPMA0GA1UEBwwGQW5r\nYXJhMRIwEAYDVQQKDAlTcGluZXggSU8xEDAOBgNVBAsMB0dhdGV3YXkxEjAQBgNV\nBAMMCVNwaW5leCBJTzAeFw0yNDA3MDYxMjUyMjNaFw0yNDA4MDUxMjUyMjNaMGkx\nCzAJBgNVBAYTAlRSMQ8wDQYDVQQIDAZBbmthcmExDzANBgNVBAcMBkFua2FyYTES\nMBAGA1UECgwJU3BpbmV4IElPMRAwDgYDVQQLDAdHYXRld2F5MRIwEAYDVQQDDAlT\ncGluZXggSU8wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC2ddspIawV\nLNaPhzUEsXy9W/MTOd5ywDfEEj4K/BuOfct2LN06kyVCY0LLs5drMWpiWqrBKwFR\nwdSvRGNZsxfoF/aaFBVpSqHyPVZ4iLPEv5K15aj2dggqApudN9X2Vpe2ugWMBCjy\nZ1QaUWkP+OfYAE/IXcoqt03XGNJJGfzCukQIB6H9Y+XJ+0cjZe92i/gucsUbckzJ\nLx0I6L0n1ramSarsr7Z9pGw+FCL/nJ0NQJCDT7BZJRIL48zlrO3BVuw7aIxJw4ia\nm2OndidgMR2vkRuBA/JdDQ5Lj9yAre8sunZAB4in0JaOZ/jZNTelKwFMlgcD2kIl\n4k0PsLw+7dwjAgMBAAGjMjAwMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFHU\nlmc2Rot4lEeP4IxhgAoZDQaOMA0GCSqGSIb3DQEBCwUAA4IBAQAA3k/U5j6FNqLg\n8rbK3GSIazmRo3+KrJiRVfikfKIh3djRGc/nUX2czghAAbllzeA5YYbqpnCOSWVb\n7JtiIdLpdowltW1F1n6ETH2X7uwf1T2e+rMlZwRNgRF8aXeBIfNspomqlLEbb8Sz\nQYpFfNrUKay+np08td/wnWGOqnGTFGlSEbKithTCmvK1l3J4u6b4HG+4/uNv7oys\noEjsH1znelAOaVd55kJAIn+VKPyqrTeK1sLruvjXTIc4mTD9aFX5oXOLduSzHIea\nq7dv5GbezTL7nD7k9FjhsTGVOFPlhJfMrf13AYKQXF8Ubgdsfa1Fd19pkpAeM+P/\nV3bqB8nx\n-----END CERTIFICATE-----\n";
static const char client_cert[] = "-----BEGIN CERTIFICATE-----\nMIIDzzCCAregAwIBAgICEREwDQYJKoZIhvcNAQELBQAwaTELMAkGA1UEBhMCVFIx\nDzANBgNVBAgMBkFua2FyYTEPMA0GA1UEBwwGQW5rYXJhMRIwEAYDVQQKDAlTcGlu\nZXggSU8xEDAOBgNVBAsMB0dhdGV3YXkxEjAQBgNVBAMMCVNwaW5leCBJTzAeFw0y\nNDA3MDYxMjUyMjdaFw0yNDA4MDUxMjUyMjdaMGkxCzAJBgNVBAYTAlRSMQ8wDQYD\nVQQIDAZBbmthcmExDzANBgNVBAcMBkFua2FyYTESMBAGA1UECgwJU3BpbmV4IElP\nMRAwDgYDVQQLDAdHYXRld2F5MRIwEAYDVQQDDAlTcGluZXggSU8wggEiMA0GCSqG\nSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDL6sZWXF6NyVm7V1tOfg0HMp2CFx1i58pd\ndhYHDCq/hF3lL5x4H/GwYBCXiap6f/19wgxA/cGu76TJaxSwiA+cBYBCUKYg5LM5\nJo+W6U0XaNbX2sMF7muI3MAKl33pwP6HUJN7DFjFu0f3gXeMJ/Ymhae1e5zbvPPz\ns6UZL+FXlpMy72N643SEj/p6PM8lvNf1rfF1CdfZRtst9qJE43To37N5/U3Oqr4i\nJMwmlgE33Xbjjt+Ds+UwbZepm2F90nGIBaHxlo6ogm7I4kolKVJg4qWiQeMRIF2I\nr1AE/JGKX5wfN6fvXJx2OEDRNN/60yOiqY+hly2kTMQMtDcoKnPDAgMBAAGjgYAw\nfjAnBgNVHREEIDAegglzcGluZXguaW+CEWdhdGV3YXkuc3BpbmV4LmlvMBMGA1Ud\nJQQMMAoGCCsGAQUFBwMBMB0GA1UdDgQWBBRMmq7NF/qRNGgSDWCr4FY/+rybFDAf\nBgNVHSMEGDAWgBRR1JZnNkaLeJRHj+CMYYAKGQ0GjjANBgkqhkiG9w0BAQsFAAOC\nAQEAK0JEPfVFePNWU5CNLU0FV8Y+bkcI3Ccn5sxbc1jtuDXbWWh7wYCHDpNANnMt\nKpR+xmO9Fh3HP+ZTzkaJ0TT8roaLtNyQbw1BuzCt4t19smiqCt97BKYkkU6esXhz\nTC7ZWIUJC4aHp6sQDT9x3nZ6EvRjWeMH7OLGU4fHmi7MuLlfC4DnGc7tlCLxg3ga\nSL+yDPTC1b1tw46x2S2dSYQ4d36uYo/dw/sOJ+LaXpJo0l2WpOUqIZ6X4a2HVEui\naxBga4DEx0cDrSABVN50gUpOz6o7iJk7Qk7BnjUQhOllKDByQNcAg0kTa6FmKEJi\nS8IecBfwl6wgZ4u7x5nnjJO+3w==\n-----END CERTIFICATE-----\n";
static const char client_key[] = "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC2ddspIawVLNaP\nhzUEsXy9W/MTOd5ywDfEEj4K/BuOfct2LN06kyVCY0LLs5drMWpiWqrBKwFRwdSv\nRGNZsxfoF/aaFBVpSqHyPVZ4iLPEv5K15aj2dggqApudN9X2Vpe2ugWMBCjyZ1Qa\nUWkP+OfYAE/IXcoqt03XGNJJGfzCukQIB6H9Y+XJ+0cjZe92i/gucsUbckzJLx0I\n6L0n1ramSarsr7Z9pGw+FCL/nJ0NQJCDT7BZJRIL48zlrO3BVuw7aIxJw4iam2On\ndidgMR2vkRuBA/JdDQ5Lj9yAre8sunZAB4in0JaOZ/jZNTelKwFMlgcD2kIl4k0P\nsLw+7dwjAgMBAAECggEAHLhaGimCiJtpXefxQ1RcEgMOX3PdR8sUMWjnsDCfy82R\nlaqZMMD8UpdaP8MnQ0hgz6t9iPC9K+0qjmNhj2XT469wnISAcaA9npTjbrn3MLHb\npNsfaJq1TUY3esdRBrikTS8PHsuBgH/IQBOZdISq8G1CzFi1sQSacZBRerqRoTrj\n4CBIR45lpS8QAi4Qv568qs0h/Eq3MZ47ak5VimB13o2eDLt2yJTrrejvV5QwG39s\n3KDrGFAE1CfMB0JGJQrEfjIJZXdGca2QqyQZVBVmeTJDyVWOTYrNSW5+tiU3IwWq\ncOKgi2PhgQKBgQDlq9TZY6vU59wi3GKXEqG3iwk/ImK0axj2qLoJm6WU4s0xO6YZ\nVEiHo+89lliJjgNDC7N/yqclZPbUtNR+oKtQ3bgs1yfOkhADD79JvBNo0Sjy+tmD\nYH9jzwWd2UMBtggXoUilqHcW4J4gyEIHTeSwoIH5j6e9L0O6DNe2AEWLFwKBgQC8\ngAn0dRIIdHibx02hIDwmkqRXCppk67Zk0YLZ3TboV8YnHYO7IST9aF/xhKkRQcM6\nZLTDsnW4hUiclwqmxQd9HsLZEuLnTmyKrYxg6t1krry8eKaJlYadxx7hL6HuQ97u\nvdzECiV1LdPxaT1K6M1O7QLGJNf2D1qaPnewZa47AQKBgC/3L/6wkNNM2uQwMJ/Y\nqtx/djFKruHUQqmzd/AOVqgTKgvpMfH7kOES6kSCb7WzsVeyfeCPU2YqB6NPh4a5\nOl3rfhOLUFXf6gDJajwCgDQcGBs6FnlfmlODHboyFRJyBfSFVEYxuJ+tzRls7mMl\nrWjjm3FuRerMM1dEH0XtK+U7\n-----END PRIVATE KEY-----\n";
struct mqtt_utf8 pass, user_name;
LOG_MODULE_REGISTER(mqtt_simple, CONFIG_MQTT_SIMPLE_LOG_LEVEL);
int ret;
int64_t timestamp;
char compareUart[7];
struct device* uart;
/* Buffers for MQTT client. */
static uint8_t rx_buffer[2520];
static uint8_t tx_buffer[2520];
static uint8_t payload_buf[4096];
char atBuffer[50];
/* The mqtt client struct */
static struct mqtt_client client;
bool sendTimestamp = false;
/* MQTT Broker details. */
static struct sockaddr_storage broker;
/* File descriptor */
static struct pollfd fds;
// /*Buffers for UART*/
// char* UART_rx_buffer[5000];
// char* UART_tx_buffer[2048];
bool idleDetected = false;
bool mqttConfigArrived = false;
uint16_t uartInterrupt = 0;
void my_work_handler(struct k_work* work);
static int fds_init(struct mqtt_client* c);
#define UART_IDLE_DETECT_TIMEOUT K_MSEC(1)
K_WORK_DEFINE(my_work, my_work_handler);
__attribute__((packed)) struct mqtt_data {
char ip[20];
uint32_t port;
char sub_topic[20];
char pub_topic[20];
char client_id[20];
char username[25];
char password[50];
};
// char client_key[1750]; // İstemci özel anahtarı
// char client_cert[1400]; // İstemci sertifikası
// char certificate[1400]; // CA sertifikası
struct mqtt_data mqtt_configs;
void timeout_handler(struct k_timer* timer_id)
{
LOG_INF("Timeout handler for UART %d", uartInterrupt);
idleDetected = true;
k_work_submit(&my_work);
}
K_TIMER_DEFINE(my_timeout_timer, timeout_handler, NULL);
#if defined(CONFIG_NRF_MODEM_LIB)
/**@brief Recoverable modem library error. */
void nrf_modem_recoverable_error_handler(uint32_t err)
{
LOG_ERR("Modem library recoverable error: %u", (unsigned int)err);
}
#endif /* defined(CONFIG_NRF_MODEM_LIB) */
#if defined(CONFIG_LWM2M_CARRIER)
K_SEM_DEFINE(carrier_registered, 0, 1);
int lwm2m_carrier_event_handler(const lwm2m_carrier_event_t* event)
{
switch (event->type) {
case LWM2M_CARRIER_EVENT_BSDLIB_INIT:
LOG_INF("LWM2M_CARRIER_EVENT_BSDLIB_INIT");
break;
case LWM2M_CARRIER_EVENT_CONNECTING:
LOG_INF("LWM2M_CARRIER_EVENT_CONNECTING");
break;
case LWM2M_CARRIER_EVENT_CONNECTED:
LOG_INF("LWM2M_CARRIER_EVENT_CONNECTED");
break;
case LWM2M_CARRIER_EVENT_DISCONNECTING:
LOG_INF("LWM2M_CARRIER_EVENT_DISCONNECTING");
break;
case LWM2M_CARRIER_EVENT_DISCONNECTED:
LOG_INF("LWM2M_CARRIER_EVENT_DISCONNECTED");
break;
case LWM2M_CARRIER_EVENT_BOOTSTRAPPED:
LOG_INF("LWM2M_CARRIER_EVENT_BOOTSTRAPPED");
break;
case LWM2M_CARRIER_EVENT_REGISTERED:
LOG_INF("LWM2M_CARRIER_EVENT_REGISTERED");
k_sem_give(&carrier_registered);
break;
case LWM2M_CARRIER_EVENT_DEFERRED:
LOG_INF("LWM2M_CARRIER_EVENT_DEFERRED");
break;
case LWM2M_CARRIER_EVENT_FOTA_START:
LOG_INF("LWM2M_CARRIER_EVENT_FOTA_START");
break;
case LWM2M_CARRIER_EVENT_REBOOT:
LOG_INF("LWM2M_CARRIER_EVENT_REBOOT");
break;
case LWM2M_CARRIER_EVENT_LTE_READY:
LOG_INF("LWM2M_CARRIER_EVENT_LTE_READY");
break;
case LWM2M_CARRIER_EVENT_ERROR:
LOG_ERR("LWM2M_CARRIER_EVENT_ERROR: code %d, value %d",
((lwm2m_carrier_event_error_t*)event->data)->code,
((lwm2m_carrier_event_error_t*)event->data)->value);
break;
default:
LOG_WRN("Unhandled LWM2M_CARRIER_EVENT: %d", event->type);
break;
}
return 0;
}
#endif /* defined(CONFIG_LWM2M_CARRIER) */
/**@brief Function to print strings without null-termination
*/
static void data_print(uint8_t* prefix, uint8_t* data, size_t len)
{
char buf[len + 1];
memcpy(buf, data, len);
buf[len] = 0;
LOG_INF("%s%s", log_strdup(prefix), log_strdup(buf));
}
/**@brief Function to publish data on the configured topic
*/
static int data_publish(struct mqtt_client* c, enum mqtt_qos qos,
uint8_t* data, size_t len, struct mqtt_utf8* topic)
{
struct mqtt_publish_param param;
param.message.topic.qos = qos;
param.message.topic.topic.utf8 = topic;
param.message.topic.topic.size = strlen(topic);
param.message.payload.data = data;
param.message.payload.len = len;
param.message_id = sys_rand32_get();
param.dup_flag = 0;
param.retain_flag = 0;
data_print("Publishing: ", data, len);
LOG_INF("to topic: %s len: %u",
topic,
(unsigned int)strlen(topic));
return mqtt_publish(c, ¶m);
}
/**@brief Function to subscribe to the configured topic
*/
static int subscribe(void)
{
struct mqtt_topic subscribe_topic = {
.topic = {
.utf8 = mqtt_configs.sub_topic,
.size = strlen(mqtt_configs.sub_topic) },
.qos = MQTT_QOS_1_AT_LEAST_ONCE
};
const struct mqtt_subscription_list subscription_list = {
.list = &subscribe_topic,
.list_count = 1,
.message_id = 1234
};
LOG_INF("Subscribing to: %s len %u", mqtt_configs.sub_topic,
(unsigned int)strlen(mqtt_configs.sub_topic));
return mqtt_subscribe(&client, &subscription_list);
}
static void myuart_send(struct device* uart, char* szStr)
{
size_t i;
unsigned char temp;
int size = strlen(szStr);
char buf[size + 1];
strcpy(buf, szStr);
buf[size] = '$';
for (uint32_t i = 0; i < size + 1; i++) {
uart_poll_out(uart, buf[i]);
LOG_INF("%c", buf[i]);
}
}
/**@brief Function to read the published payload.
*/
static int publish_get_payload(struct mqtt_client* c, size_t length)
{
if (length > sizeof(payload_buf)) {
return -EMSGSIZE;
}
return mqtt_readall_publish_payload(c, payload_buf, length);
}
/**@brief MQTT client event handler
*/
void mqtt_evt_handler(struct mqtt_client* const c,
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;
}
LOG_INF("MQTT client connected");
subscribe();
char* data = "{\"type\":\"READY\"}";
data_publish(&client,
MQTT_QOS_1_AT_LEAST_ONCE,
data,
strlen(data),
mqtt_configs.pub_topic);
break;
case MQTT_EVT_DISCONNECT:
LOG_INF("MQTT client disconnected: %d", evt->result);
break;
case MQTT_EVT_PUBLISH: {
const struct mqtt_publish_param* p = &evt->param.publish;
LOG_INF("MQTT PUBLISH result=%d len=%d",
evt->result, p->message.payload.len);
err = publish_get_payload(c, p->message.payload.len);
if (p->message.topic.qos == MQTT_QOS_1_AT_LEAST_ONCE) {
const struct mqtt_puback_param ack = {
.message_id = p->message_id
};
/* Send acknowledgment. */
mqtt_publish_qos1_ack(&client, &ack);
}
if (err >= 0) {
// data_print("Received: ", payload_buf,
// p->message.payload.len);
/* Send readed data to NRF52*/
char buf[p->message.payload.len + 1];
for (uint32_t i = 0; i < p->message.payload.len + 1; i++) {
buf[i] = '\0';
}
memcpy(buf, payload_buf, p->message.payload.len);
// printf(UART_rx_buffer,"%s",buf);
// const char* tls_version = mbedtls_ssl_get_version(c->transport.tls.mbedtls_ssl);
// LOG_INF("TLS version: %s", log_strdup(tls_version))
if (!strstr((char*)mqtt_configs.pub_topic, (char*)buf)) {
buf[p->message.payload.len] = '$';
for (uint32_t i = 0; i < p->message.payload.len + 1; i++) {
uart_poll_out(uart, buf[i]);
printk("%c", buf[i]);
}
printk("\n");
k_msleep(2000);
} else {
printk("THE SAME %s -- %s\n", buf, mqtt_configs.pub_topic);
}
} else {
LOG_ERR("publish_get_payload failed: %d", err);
LOG_ERR("Disconnecting MQTT client...");
err = mqtt_disconnect(c);
if (err) {
LOG_ERR("Could not disconnect: %d", err);
}
}
} 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:
if (evt->result != 0) {
LOG_ERR("MQTT SUBACK error: %d", evt->result);
break;
}
LOG_INF("SUBACK packet id: %u", evt->param.suback.message_id);
break;
case MQTT_EVT_PINGRESP:
if (evt->result != 0) {
LOG_ERR("MQTT PINGRESP error: %d", evt->result);
}
break;
default:
LOG_INF("Unhandled MQTT event type: %d", evt->type);
break;
}
}
/**@brief Resolves the configured hostname and
* initializes the MQTT broker structure
*/
static int broker_init(void)
{
int err;
struct addrinfo* result;
struct addrinfo* addr;
struct addrinfo hints = {
.ai_family = AF_INET,
.ai_socktype = SOCK_STREAM
};
err = getaddrinfo(mqtt_configs.ip, NULL, &hints, &result);
if (err) {
LOG_ERR("getaddrinfo failed: %d", err);
return -ECHILD;
}
addr = result;
/* Look for address of the broker. */
while (addr != NULL) {
/* IPv4 Address. */
if (addr->ai_addrlen == sizeof(struct sockaddr_in)) {
struct sockaddr_in* broker4 = ((struct sockaddr_in*)&broker);
char ipv4_addr[NET_IPV4_ADDR_LEN];
broker4->sin_addr.s_addr = ((struct sockaddr_in*)addr->ai_addr)->sin_addr.s_addr;
broker4->sin_family = AF_INET;
broker4->sin_port = htons(mqtt_configs.port);
inet_ntop(AF_INET, &broker4->sin_addr.s_addr,
ipv4_addr, sizeof(ipv4_addr));
LOG_INF("IPv4 Address found %s", log_strdup(ipv4_addr));
break;
} else {
LOG_ERR("ai_addrlen = %u should be %u or %u",
(unsigned int)addr->ai_addrlen,
(unsigned int)sizeof(struct sockaddr_in),
(unsigned int)sizeof(struct sockaddr_in6));
}
addr = addr->ai_next;
}
/* Free the address. */
freeaddrinfo(result);
return err;
}
#if defined(CONFIG_NRF_MODEM_LIB)
#define IMEI_LEN 15
#define CGSN_RESPONSE_LENGTH 19
#define CLIENT_ID_LEN sizeof("nrf-") + IMEI_LEN
#else
#define RANDOM_LEN 10
#define CLIENT_ID_LEN sizeof(CONFIG_BOARD) + 1 + RANDOM_LEN
#endif /* defined(CONFIG_NRF_MODEM_LIB) */
/* Function to get the client id */
static const uint8_t* client_id_get(void)
{
static uint8_t client_id[MAX(sizeof(CONFIG_MQTT_CLIENT_ID),
CLIENT_ID_LEN)];
if (strlen(mqtt_configs.client_id) > 0) {
snprintf(client_id, sizeof(client_id), "%s",
mqtt_configs.client_id);
goto exit;
}
#if defined(CONFIG_NRF_MODEM_LIB)
char imei_buf[CGSN_RESPONSE_LENGTH + 1];
int err;
if (!IS_ENABLED(CONFIG_AT_CMD_SYS_INIT)) {
err = at_cmd_init();
if (err) {
LOG_ERR("at_cmd failed to initialize, error: %d", err);
goto exit;
}
}
err = at_cmd_write("AT+CGSN", imei_buf, sizeof(imei_buf), NULL);
if (err) {
LOG_ERR("Failed to obtain IMEI, error: %d", err);
goto exit;
}
imei_buf[IMEI_LEN] = '\0';
snprintf(client_id, sizeof(client_id), "nrf-%.*s", IMEI_LEN, imei_buf);
#else
uint32_t id = sys_rand32_get();
snprintf(client_id, sizeof(client_id), "%s-%010u", CONFIG_BOARD, id);
#endif /* !defined(NRF_CLOUD_CLIENT_ID) */
exit:
LOG_DBG("client_id = %s", log_strdup(client_id));
return client_id;
}
/**@brief Initialize the MQTT client structure
*/
static int client_init(struct mqtt_client* client)
{
int err;
mqtt_client_init(client);
err = broker_init();
if (err) {
LOG_ERR("Failed to initialize broker connection");
return err;
}
pass.size = strlen(mqtt_configs.password);
pass.utf8 = (uint8_t*)mqtt_configs.password;
user_name.size = strlen(mqtt_configs.username);
user_name.utf8 = (uint8_t*)mqtt_configs.username;
/* MQTT client configuration */
client->broker = &broker;
client->evt_cb = mqtt_evt_handler;
client->client_id.utf8 = client_id_get();
client->client_id.size = strlen(client->client_id.utf8);
if (strlen(mqtt_configs.password) > 2)
client->password = &pass;
else
client->password = NULL;
if (strlen(mqtt_configs.username) > 2)
client->user_name = &user_name;
else
client->user_name = 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 (strlen(ca_cert) > 2 && strlen(client_cert) > 2 && strlen(client_key) > 2) {
static sec_tag_t sec_tag_list[] = { CONFIG_MQTT_TLS_SEC_TAG};
err = tls_credential_add(CONFIG_MQTT_TLS_SEC_TAG, TLS_CREDENTIAL_CA_CERTIFICATE,
ca_cert, strlen(ca_cert));
if (err) {
printk("CA CERTIFICATE ERROR %d", err);
}
err = tls_credential_add(CONFIG_MQTT_TLS_SEC_TAG, TLS_CREDENTIAL_SERVER_CERTIFICATE,
client_cert, strlen(client_cert));
if (err) {
printk("CLIENT CERTIFICATE ERROR %d", err);
}
err = tls_credential_add(CONFIG_MQTT_TLS_SEC_TAG, TLS_CREDENTIAL_PRIVATE_KEY,
client_key, strlen(client_key));
if (err) {
printk("CLIENT KEY ERROR %d", err);
}
struct mqtt_sec_config tls_config = {
.peer_verify = MBEDTLS_SSL_VERIFY_NONE,
.cipher_list = NULL,
.sec_tag_list = sec_tag_list,
.sec_tag_count = ARRAY_SIZE(sec_tag_list),
.hostname = NULL,
};
client->transport.type = MQTT_TRANSPORT_NON_SECURE;
client->transport.tls.config = tls_config;
} else {
client->transport.type = MQTT_TRANSPORT_NON_SECURE;
}
return err;
}
/**@brief Initialize the file descriptor structure used by poll.
*/
static int fds_init(struct mqtt_client* c)
{
if (c->transport.type == MQTT_TRANSPORT_NON_SECURE) {
fds.fd = c->transport.tcp.sock;
printk("TCP SOCKET ON\n");
} else {
#if defined(CONFIG_MQTT_LIB_TLS)
fds.fd = c->transport.tls.sock;
printk("TLS SOCKET ON\n");
#else
return -ENOTSUP;
#endif
}
fds.events = POLLIN;
return 0;
}
#if defined(CONFIG_DK_LIBRARY)
static void button_handler(uint32_t button_states, uint32_t has_changed)
{
if (has_changed & button_states & BIT(CONFIG_BUTTON_EVENT_BTN_NUM - 1)) {
int ret;
ret = data_publish(&client,
MQTT_QOS_0_AT_MOST_ONCE,
CONFIG_BUTTON_EVENT_PUBLISH_MSG,
sizeof(CONFIG_BUTTON_EVENT_PUBLISH_MSG) - 1, "acrux/deneme");
if (ret) {
LOG_ERR("Publish failed: %d", ret);
}
}
}
#endif
/**@brief Configures modem to provide LTE link. Blocks until link is
* successfully established.
*/
static int modem_configure(void)
{
#if defined(CONFIG_LTE_LINK_CONTROL)
/* Turn off LTE power saving features for a more responsive demo. Also,
* request power saving features before network registration. Some
* networks rejects timer updates after the device has registered to the
* LTE network.
*/
int err;
printk("Disabling PSM and eDRX");
lte_lc_psm_req(false);
lte_lc_edrx_req(false);
if (IS_ENABLED(CONFIG_LTE_AUTO_INIT_AND_CONNECT)) {
/* Do nothing, modem is already turned on
* and connected.
*/
} else {
#if defined(CONFIG_LWM2M_CARRIER)
/* Wait for the LWM2M_CARRIER to configure the modem and
* start the connection.
*/
LOG_INF("Waitng for carrier registration...");
k_sem_take(&carrier_registered, K_FOREVER);
LOG_INF("Registered!");
#else /* defined(CONFIG_LWM2M_CARRIER) */
int err;
printk("LTE Link Connecting...");
err = lte_lc_init_and_connect();
if (err) {
LOG_INF("Failed to establish LTE connection: %d", err);
return err;
}
printk("LTE Link Connected!");
#endif /* defined(CONFIG_LWM2M_CARRIER) */
}
#endif /* defined(CONFIG_LTE_LINK_CONTROL) */
return 0;
}
static uint8_t uart_buf[2048];
char uartCome[5200];
char uartBufferLast;
char nextLine[] = "\n";
void uart_cb(struct device* x)
{
int data_length = 10;
while (uart_irq_update(x) && uart_irq_is_pending(x)) {
if (uart_irq_rx_ready(x)) {
k_timer_start(&my_timeout_timer, UART_IDLE_DETECT_TIMEOUT, K_NO_WAIT);
data_length = uart_fifo_read(x, uart_buf, sizeof(uartCome));
uartCome[uartInterrupt] = uart_buf[0];
uartInterrupt += data_length;
// uart_buf[data_length] = 0;
}
}
// uartBufferLast = uart_buf[0];
// if (uartBufferLast == 21)
// {
// uartInterrupt = 0;
// strcpy(uartCome, uartBuffer);
// memset(uartBuffer, '\0', sizeof(uartBuffer));
// }
// else
// {
// uartBuffer[uartInterrupt] = uart_buf[0];
// uartInterrupt++;
// }
}
uint32_t start_time;
uint32_t stop_time;
uint32_t cycles_spent;
int err;
char timestampChar[124];
int counter;
char compareUartCharacter[7];
__attribute__((packed)) struct LTEDataRequest {
char deviceName[12];
char name[4];
uint8_t data[40];
uint16_t length;
uint32_t timeStampt;
};
void my_work_handler(struct k_work* work)
{
if (sendTimestamp == false && timestamp != 0) {
sprintf(timestampChar, "{\"type\":\"TIME_STAMP\",\"package_count\":1,\"self_count\":0,\"data\":\"%d\"}", timestamp);
printk(timestampChar);
myuart_send(uart, timestampChar);
sendTimestamp = true;
}
// strncpy(compareUart, uartCome, 6);
// printk("\n%sbu\n",compareUart);
k_msleep(2);
// printk("firstCaharacterCome:%c",uartCome[0]);
if (idleDetected) {
idleDetected = false;
counter++;
printk("\n%d\n", counter);
memset(compareUart, '\0', sizeof(compareUart));
printk("karsilastirma icinde SIZE:%d\n", uartInterrupt);
if (sizeof(uartCome) > 1024) {
memcpy(&mqtt_configs, (struct mqtt_data*)uartCome, sizeof(struct mqtt_data));
// memcpy(client_key, uartCome + sizeof(struct mqtt_data), sizeof(client_key));
// memcpy(client_cert, uartCome + sizeof(struct mqtt_data) + sizeof(client_key), sizeof(client_cert));
// memcpy(certificate, uartCome + sizeof(struct mqtt_data) + sizeof(client_key) + sizeof(client_cert), sizeof(certificate));
printk("MQTT DATA FOUND, IP=%s PORT:%d\nUSER:%s\nPASSWORD:%s\n", mqtt_configs.ip, mqtt_configs.port, mqtt_configs.username, mqtt_configs.password);
printk("CLIENT CERTF : %s\n", client_cert);
printk("Server CERTF : %s\n", ca_cert);
printk("Client Key : %s\n", client_key);
mqttConfigArrived = true;
} else {
struct LTEDataRequest req;
memcpy(&req, (struct LTEDataRequest*)uartCome, uartInterrupt);
printk("------ req %s ----------\n", req.deviceName);
ret = data_publish(&client,
MQTT_QOS_1_AT_LEAST_ONCE,
&req,
sizeof(req),
mqtt_configs.pub_topic);
}
if (ret) {
// myuart_send(uart,"n\n");
printk("n\n");
LOG_ERR("Publish failed: %d", ret);
}
memset(uartCome, '\0', sizeof(uartCome));
uartInterrupt = 0;
}
}
void my_timer_handler(struct k_timer* dummy)
{
k_work_submit(&my_work);
}
K_TIMER_DEFINE(my_timer, my_timer_handler, NULL);
/* start periodic timer that expires once every second */
void datetimeevt(struct date_time_evt* evt)
{
evt->type = DATE_TIME_OBTAINED_MODEM;
}
void main(void)
{
at_cmd_init();
uart = device_get_binding("UART_1");
uart_irq_callback_set(uart, uart_cb);
uart_irq_tx_disable(uart);
uart_irq_rx_enable(uart);
int err;
uint32_t connect_attempt = 0;
// #if defined(CONFIG_MQTT_LIB_TLS)
// err = certificates_provision();
// if (err != 0) {
// LOG_ERR("Failed to provision certificates");
// return;
// }
// #endif /* defined(CONFIG_MQTT_LIB_TLS) */
do {
err = modem_configure();
if (err) {
LOG_INF("Retrying in %d seconds",
CONFIG_LTE_CONNECT_RETRY_DELAY_S);
k_sleep(K_SECONDS(CONFIG_LTE_CONNECT_RETRY_DELAY_S));
}
} while (err);
int counter = 0;
while (!mqttConfigArrived) {
if(counter %20 == 0){
myuart_send(uart, "{\"type\":\"READY\",\"package_count\":1,\"self_count\":0}");
LOG_INF("READY TO GET MQTT CONFIG");
}
counter++;
k_msleep(1000);
}
err = client_init(&client);
if (err != 0) {
LOG_ERR("client_init: %d", err);
return;
}
#if defined(CONFIG_DK_LIBRARY)
dk_buttons_init(button_handler);
#endif
do_connect:
if (connect_attempt++ > 0) {
LOG_INF("Reconnecting in %d seconds...",
CONFIG_MQTT_RECONNECT_DELAY_S);
k_sleep(K_SECONDS(CONFIG_MQTT_RECONNECT_DELAY_S));
}
err = mqtt_connect(&client);
if (err != 0) {
LOG_ERR("mqtt_connect %d", err);
goto do_connect;
}
err = fds_init(&client);
if (err != 0) {
LOG_ERR("fds_init: %d", err);
return;
}
date_time_update_async(datetimeevt);
k_timer_start(&my_timer, K_MSEC(100), K_MSEC(100));
while (1) {
start_time = k_cycle_get_32();
err = poll(&fds, 1, mqtt_keepalive_time_left(&client));
if (err < 0) {
printk("poll: %d", errno);
break;
}
err = mqtt_live(&client);
if ((err != 0) && (err != -EAGAIN)) {
LOG_ERR("ERROR: mqtt_live: %d", err);
break;
}
if ((fds.revents & POLLIN) == POLLIN) {
err = mqtt_input(&client);
if (err != 0) {
printk("mqtt_input: %d", err);
break;
}
}
if ((fds.revents & POLLERR) == POLLERR) {
printk("POLLERR");
break;
}
if ((fds.revents & POLLNVAL) == POLLNVAL) {
printk("POLLNVAL");
break;
}
date_time_now(×tamp);
stop_time = k_cycle_get_32();
cycles_spent = stop_time - start_time;
}
printk("Disconnecting MQTT client...");
err = mqtt_disconnect(&client);
if (err) {
LOG_ERR("Could not disconnect MQTT client: %d", err);
}
goto do_connect;
}