diff --git a/README.md b/README.md index ab13be68e..01a98ff3e 100644 --- a/README.md +++ b/README.md @@ -191,6 +191,7 @@ App|Description [picow_httpd](pico_w/wifi/httpd) | Runs a LWIP HTTP server test app [picow_http_client](pico_w/wifi/http_client) | Demonstrates how to make http and https requests [picow_http_client_verify](pico_w/wifi/http_client) | Demonstrates how to make a https request with server authentication +[picow_mqtt_client](pico_w/wifi/mqtt) | Demonstrates how to implement an MQTT client application #### FreeRTOS examples diff --git a/pico_w/wifi/CMakeLists.txt b/pico_w/wifi/CMakeLists.txt index 4599a21cd..31797084b 100644 --- a/pico_w/wifi/CMakeLists.txt +++ b/pico_w/wifi/CMakeLists.txt @@ -18,6 +18,7 @@ else() add_subdirectory_exclude_platforms(tcp_server) add_subdirectory_exclude_platforms(udp_beacon) add_subdirectory_exclude_platforms(http_client) + add_subdirectory_exclude_platforms(mqtt) if (NOT PICO_MBEDTLS_PATH) message("Skipping tls examples as PICO_MBEDTLS_PATH is not defined") diff --git a/pico_w/wifi/lwipopts_examples_common.h b/pico_w/wifi/lwipopts_examples_common.h index 217cb1357..3cc083c64 100644 --- a/pico_w/wifi/lwipopts_examples_common.h +++ b/pico_w/wifi/lwipopts_examples_common.h @@ -20,7 +20,9 @@ #define MEM_LIBC_MALLOC 0 #endif #define MEM_ALIGNMENT 4 +#ifndef MEM_SIZE #define MEM_SIZE 4000 +#endif #define MEMP_NUM_TCP_SEG 32 #define MEMP_NUM_ARP_QUEUE 10 #define PBUF_POOL_SIZE 24 diff --git a/pico_w/wifi/mqtt/CMakeLists.txt b/pico_w/wifi/mqtt/CMakeLists.txt new file mode 100644 index 000000000..23dfa250f --- /dev/null +++ b/pico_w/wifi/mqtt/CMakeLists.txt @@ -0,0 +1,79 @@ +# Define the host name of the MQTT server in an environment variable or pass it to cmake, +# e.g. cmake -DMQTT_SERVER=myserver .. + +if (DEFINED ENV{MQTT_SERVER} AND (NOT MQTT_SERVER)) + set(MQTT_SERVER $ENV{MQTT_SERVER}) + message("Using MQTT_SERVER from environment ('${MQTT_SERVER}')") +endif() +if (NOT MQTT_SERVER) + message("Skipping MQTT example as MQTT_SERVER is not defined") + return() +endif() +# Define the name of an MQTT broker/server to enable this example +set(MQTT_SERVER "${MQTT_SERVER}" CACHE INTERNAL "MQTT server for examples") + +if (DEFINED ENV{MQTT_USERNAME} AND (NOT MQTT_USERNAME)) + set(MQTT_USERNAME $ENV{MQTT_USERNAME}) + message("Using MQTT_USERNAME from environment ('${MQTT_USERNAME}')") +endif() +set(MQTT_USERNAME "${MQTT_USERNAME}" CACHE INTERNAL "MQTT user name for examples") +if (DEFINED ENV{MQTT_PASSWORD} AND (NOT MQTT_PASSWORD)) + set(MQTT_PASSWORD $ENV{MQTT_PASSWORD}) + message("Using MQTT_PASSWORD from environment") +endif() +set(MQTT_PASSWORD "${MQTT_PASSWORD}" CACHE INTERNAL "MQTT password for examples") + +# Set path to the certificate include file +if (NOT MQTT_CERT_PATH) + set(MQTT_CERT_PATH ${CMAKE_CURRENT_LIST_DIR}/certs/${MQTT_SERVER}) +endif() + +# Set the name of the certificate include file +if (NOT MQTT_CERT_INC) + set(MQTT_CERT_INC mqtt_client.inc) +endif() + +set(TARGET_NAME picow_mqtt_client) +add_executable(${TARGET_NAME} + mqtt_client.c + ) +target_link_libraries(${TARGET_NAME} + pico_stdlib + hardware_adc + pico_cyw43_arch_lwip_threadsafe_background + pico_lwip_mqtt + pico_mbedtls + pico_lwip_mbedtls + ) +target_include_directories(${TARGET_NAME} PRIVATE + ${CMAKE_CURRENT_LIST_DIR} + ${CMAKE_CURRENT_LIST_DIR}/.. # for our common lwipopts or any other standard includes, if required + ) +target_compile_definitions(${TARGET_NAME} PRIVATE + WIFI_SSID=\"${WIFI_SSID}\" + WIFI_PASSWORD=\"${WIFI_PASSWORD}\" + MQTT_SERVER=\"${MQTT_SERVER}\" + ) +if (EXISTS "${MQTT_CERT_PATH}/${MQTT_CERT_INC}") + target_compile_definitions(${TARGET_NAME} PRIVATE + MQTT_CERT_INC=\"${MQTT_CERT_INC}\" # contains the tls certificates for MQTT_SERVER needed by the client + ALTCP_MBEDTLS_AUTHMODE=MBEDTLS_SSL_VERIFY_REQUIRED + ) + target_include_directories(${TARGET_NAME} PRIVATE + ${MQTT_CERT_PATH} + ) +endif() +if (MQTT_USERNAME AND MQTT_PASSWORD) + target_compile_definitions(${TARGET_NAME} PRIVATE + MQTT_USERNAME=\"${MQTT_USERNAME}\" + MQTT_PASSWORD=\"${MQTT_PASSWORD}\" + ) +endif() +pico_add_extra_outputs(${TARGET_NAME}) + +# Ignore warnings from lwip code +set_source_files_properties( + ${PICO_LWIP_PATH}/src/apps/altcp_tls/altcp_tls_mbedtls.c + PROPERTIES + COMPILE_OPTIONS "-Wno-unused-result" + ) \ No newline at end of file diff --git a/pico_w/wifi/mqtt/README b/pico_w/wifi/mqtt/README new file mode 100644 index 000000000..e1889bb61 --- /dev/null +++ b/pico_w/wifi/mqtt/README @@ -0,0 +1,94 @@ +# Quick start + +To use this example you will need to install an MQTT server on your network. +To install the Mosquitto MQTT client on a Raspberry Pi Linux device run the following... + +``` +sudo apt install mosquitto +sudo apt install mosquitto-clients +``` + +Check it works... + +``` +mosquitto_pub -t test_topic -m "Yes it works" -r +mosquitto_sub -t test_topic -C 1 +``` + +To allow an external client to connect to the server you will have to change the configuration. Add the following to /etc/mosquitto/conf.d/mosquitto.conf + +``` +allow_anonymous true +listener 1883 0.0.0.0 +``` + +Then restart the service. + +``` +sudo service mosquitto restart +``` + +When building the code set the host name of the MQTT server, e.g. + +``` +export MQTT_SERVER=myhost +cmake .. +``` + +The example should publish its core temperature to the /temperature topic. You can subscribe to this topic from another machine. + +``` +mosquitto_sub -h $MQTT_SERVER -t '/temperature' +``` + +You can turn the led on and off by publishing messages. + +``` +mosquitto_pub -h $MQTT_SERVER -t '/led' -m on +mosquitto_pub -h $MQTT_SERVER -t '/led' -m off +``` + +# Security + +If your server has a username and password, you can set these with the following variables. + +``` +export MQTT_USERNAME=user +export MQTT_PASSWORD=pass +``` + +Be aware that these details are sent in plain text unless you use TLS. + +## Using TLS + +To use TLS and client server authentication you need some keys and certificates for the client and server. +The `certs/makecerts.sh` script demonstrates a way to make these. +It creates a folder named after `MQTT_SERVER` containing all the required files. +From these files it generates a header file `mqtt_client.inc` included by the code. +Your server will have to be configured to use TLS and the port 8883 rather than the non-TLS port 1883. + +``` +listener 1883 127.0.0.1 + +listener 8883 0.0.0.0 +allow_anonymous true +cafile /etc/mosquitto/ca_certificates/ca.crt +certfile /etc/mosquitto/certs/server.crt +keyfile /etc/mosquitto/certs/server.key +require_certificate true +``` + +To connect to your server with the mosquitto tools in linux you will have to pass extra parameters. + +``` +mosquitto_pub -h $MQTT_SERVER --cafile $MQTT_SERVER/ca.crt --key $MQTT_SERVER/client.key --cert $MQTT_SERVER/client.crt -t /led -m on +mosquitto_sub -h $MQTT_SERVER --cafile $MQTT_SERVER/ca.crt --key $MQTT_SERVER/client.key --cert $MQTT_SERVER/client.crt -t "/temperature" +``` + +There are some shell scripts in the certs folder to reduce the amount of typing assuming `MQTT_SERVER` is defined. + +``` +cd certs +./pub.sh /led on +./sub.sh /temperature +``` diff --git a/pico_w/wifi/mqtt/certs/.gitignore b/pico_w/wifi/mqtt/certs/.gitignore new file mode 100644 index 000000000..d92150c7c --- /dev/null +++ b/pico_w/wifi/mqtt/certs/.gitignore @@ -0,0 +1,2 @@ +*/ + diff --git a/pico_w/wifi/mqtt/certs/makecerts.sh b/pico_w/wifi/mqtt/certs/makecerts.sh new file mode 100755 index 000000000..c95b9c8f8 --- /dev/null +++ b/pico_w/wifi/mqtt/certs/makecerts.sh @@ -0,0 +1,43 @@ +#!/usr/bin/bash + +if [ "${PWD##*/}" != "certs" ]; then + echo Run this in the certs folder + exit 1 +fi +if [ -z "$MQTT_SERVER" ]; then + echo Define MQTT_SERVER + exit 1 +fi +SERVER_NAME=$MQTT_SERVER + +if [ -d "$SERVER_NAME" ]; then + echo Run \"rm -fr $SERVER_NAME\" to regenerate these keys + exit 1 +fi +mkdir $SERVER_NAME +echo Generating keys in $PWD/$SERVER_NAME + +openssl genrsa -out $SERVER_NAME/ca.key 2048 +openssl req -new -x509 -days 99999 -key $SERVER_NAME/ca.key -out $SERVER_NAME/ca.crt -subj "/C=UK/ST=Cambridgeshire/L=Cambridge/O=Raspberry Pi Ltd/OU=Software/CN=rpiroot" + +openssl genrsa -out $SERVER_NAME/server.key 2048 +openssl req -new -out $SERVER_NAME/server.csr -key $SERVER_NAME/server.key -subj "/C=UK/ST=Cambridgeshire/L=Cambridge/O=Raspberry Pi Ltd/OU=Software/CN=$SERVER_NAME" +openssl x509 -req -in $SERVER_NAME/server.csr -CA $SERVER_NAME/ca.crt -CAkey $SERVER_NAME/ca.key -CAcreateserial -out $SERVER_NAME/server.crt -days 9999 + +openssl genrsa -out $SERVER_NAME/client.key 2048 +openssl req -new -out $SERVER_NAME/client.csr -key $SERVER_NAME/client.key -subj "/C=UK/ST=Cambridgeshire/L=Cambridge/O=Raspberry Pi Ltd/OU=Software/CN=$SERVER_NAME" +openssl x509 -req -in $SERVER_NAME/client.csr -CA $SERVER_NAME/ca.crt -CAkey $SERVER_NAME/ca.key -CAcreateserial -out $SERVER_NAME/client.crt -days 999 + +echo -n \#define TLS_ROOT_CERT \" > $SERVER_NAME/mqtt_client.inc +cat $SERVER_NAME/ca.crt | awk '{printf "%s\\n\\\n", $0}' >> $SERVER_NAME/mqtt_client.inc +echo "\"" >> $SERVER_NAME/mqtt_client.inc +echo >> $SERVER_NAME/mqtt_client.inc + +echo -n \#define TLS_CLIENT_KEY \" >> $SERVER_NAME/mqtt_client.inc +cat $SERVER_NAME/client.key | awk '{printf "%s\\n\\\n", $0}' >> $SERVER_NAME/mqtt_client.inc +echo "\"" >> $SERVER_NAME/mqtt_client.inc +echo >> $SERVER_NAME/mqtt_client.inc + +echo -n \#define TLS_CLIENT_CERT \" >> $SERVER_NAME/mqtt_client.inc +cat $SERVER_NAME/client.crt | awk '{printf "%s\\n\\\n", $0}' >> $SERVER_NAME/mqtt_client.inc +echo "\"" >> $SERVER_NAME/mqtt_client.inc diff --git a/pico_w/wifi/mqtt/certs/pub.sh b/pico_w/wifi/mqtt/certs/pub.sh new file mode 100755 index 000000000..38b9b7d37 --- /dev/null +++ b/pico_w/wifi/mqtt/certs/pub.sh @@ -0,0 +1,9 @@ +#/usr/bin/bash + +if [ -z "$MQTT_SERVER" ]; then + echo Define MQTT_SERVER + exit 1 +fi + +mosquitto_pub -h $MQTT_SERVER --cafile $MQTT_SERVER/ca.crt --key $MQTT_SERVER/client.key --cert $MQTT_SERVER/client.crt -t "$1" -m "$2" + diff --git a/pico_w/wifi/mqtt/certs/sub.sh b/pico_w/wifi/mqtt/certs/sub.sh new file mode 100755 index 000000000..54b9376ad --- /dev/null +++ b/pico_w/wifi/mqtt/certs/sub.sh @@ -0,0 +1,9 @@ +#/usr/bin/bash + +if [ -z "$MQTT_SERVER" ]; then + echo Define MQTT_SERVER + exit 1 +fi + +mosquitto_sub -h $MQTT_SERVER --cafile $MQTT_SERVER/ca.crt --key $MQTT_SERVER/client.key --cert $MQTT_SERVER/client.crt -t "$1" + diff --git a/pico_w/wifi/mqtt/lwipopts.h b/pico_w/wifi/mqtt/lwipopts.h new file mode 100644 index 000000000..c309d5cb3 --- /dev/null +++ b/pico_w/wifi/mqtt/lwipopts.h @@ -0,0 +1,33 @@ +#ifndef _LWIPOPTS_H +#define _LWIPOPTS_H + +// Need more memory for TLS +#ifdef MQTT_CERT_INC +#define MEM_SIZE 8000 +#endif + +// Generally you would define your own explicit list of lwIP options +// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html) +// +// This example uses a common include to avoid repetition +#include "lwipopts_examples_common.h" + +#define MEMP_NUM_SYS_TIMEOUT (LWIP_NUM_SYS_TIMEOUT_INTERNAL+1) + +#ifdef MQTT_CERT_INC +#define LWIP_ALTCP 1 +#define LWIP_ALTCP_TLS 1 +#define LWIP_ALTCP_TLS_MBEDTLS 1 +#ifndef NDEBUG +#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON +#endif +/* TCP WND must be at least 16 kb to match TLS record size + or you will get a warning "altcp_tls: TCP_WND is smaller than the RX decrypion buffer, connection RX might stall!" */ +#undef TCP_WND +#define TCP_WND 16384 +#endif // MQTT_CERT_INC + +// This defaults to 4 +#define MQTT_REQ_MAX_IN_FLIGHT 5 + +#endif diff --git a/pico_w/wifi/mqtt/mbedtls_config.h b/pico_w/wifi/mqtt/mbedtls_config.h new file mode 100644 index 000000000..f182c5661 --- /dev/null +++ b/pico_w/wifi/mqtt/mbedtls_config.h @@ -0,0 +1,6 @@ +#ifndef MBEDTLS_CONFIG_TLS_CLIENT_H +#define MBEDTLS_CONFIG_TLS_CLIENT_H + +#include "mbedtls_config_examples_common.h" + +#endif \ No newline at end of file diff --git a/pico_w/wifi/mqtt/mqtt_client.c b/pico_w/wifi/mqtt/mqtt_client.c new file mode 100644 index 000000000..b70d6885d --- /dev/null +++ b/pico_w/wifi/mqtt/mqtt_client.c @@ -0,0 +1,378 @@ +/** + * Copyright (c) 2022 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// +// Created by elliot on 25/05/24. +// +#include "pico/stdlib.h" +#include "pico/cyw43_arch.h" +#include "pico/unique_id.h" +#include "hardware/gpio.h" +#include "hardware/irq.h" +#include "hardware/adc.h" +#include "lwip/apps/mqtt.h" +#include "lwip/apps/mqtt_priv.h" // needed to set hostname +#include "lwip/dns.h" +#include "lwip/altcp_tls.h" + +// Temperature +#ifndef TEMPERATURE_UNITS +#define TEMPERATURE_UNITS 'C' // Set to 'F' for Fahrenheit +#endif + +#ifndef MQTT_SERVER +#error Need to define MQTT_SERVER +#endif + +// This file includes your client certificate for client server authentication +#ifdef MQTT_CERT_INC +#include MQTT_CERT_INC +#endif + +#ifndef MQTT_TOPIC_LEN +#define MQTT_TOPIC_LEN 100 +#endif + +typedef struct { + mqtt_client_t* mqtt_client_inst; + struct mqtt_connect_client_info_t mqtt_client_info; + char data[MQTT_OUTPUT_RINGBUF_SIZE]; + char topic[MQTT_TOPIC_LEN]; + uint32_t len; + ip_addr_t mqtt_server_address; + bool connect_done; + int subscribe_count; + bool stop_client; +} MQTT_CLIENT_DATA_T; + +#ifndef DEBUG_printf +#ifndef NDEBUG +#define DEBUG_printf printf +#else +#define DEBUG_printf(...) +#endif +#endif + +#ifndef INFO_printf +#define INFO_printf printf +#endif + +#ifndef ERROR_printf +#define ERROR_printf printf +#endif + +// how often to measure our temperature +#define TEMP_WORKER_TIME_S 10 + +// keep alive in seconds +#define MQTT_KEEP_ALIVE_S 60 + +// qos passed to mqtt_subscribe +// At most once (QoS 0) +// At least once (QoS 1) +// Exactly once (QoS 2) +#define MQTT_SUBSCRIBE_QOS 1 +#define MQTT_PUBLISH_QOS 1 +#define MQTT_PUBLISH_RETAIN 0 + +// topic used for last will and testament +#define MQTT_WILL_TOPIC "/online" +#define MQTT_WILL_MSG "0" +#define MQTT_WILL_QOS 1 + +#ifndef MQTT_DEVICE_NAME +#define MQTT_DEVICE_NAME "pico" +#endif + +// Set to 1 to add the client name to topics, to support multiple devices using the same server +#ifndef MQTT_UNIQUE_TOPIC +#define MQTT_UNIQUE_TOPIC 0 +#endif + +/* References for this implementation: + * raspberry-pi-pico-c-sdk.pdf, Section '4.1.1. hardware_adc' + * pico-examples/adc/adc_console/adc_console.c */ +static float read_onboard_temperature(const char unit) { + + /* 12-bit conversion, assume max value == ADC_VREF == 3.3 V */ + const float conversionFactor = 3.3f / (1 << 12); + + float adc = (float)adc_read() * conversionFactor; + float tempC = 27.0f - (adc - 0.706f) / 0.001721f; + + if (unit == 'C' || unit != 'F') { + return tempC; + } else if (unit == 'F') { + return tempC * 9 / 5 + 32; + } + + return -1.0f; +} + +static void pub_request_cb(__unused void *arg, err_t err) { + if (err != 0) { + ERROR_printf("pub_request_cb failed %d", err); + } +} + +static const char *full_topic(MQTT_CLIENT_DATA_T *state, const char *name) { +#if MQTT_UNIQUE_TOPIC + static char full_topic[MQTT_TOPIC_LEN]; + snprintf(full_topic, sizeof(full_topic), "/%s%s", state->mqtt_client_info.client_id, name); + return full_topic; +#else + return name; +#endif +} + +static void control_led(MQTT_CLIENT_DATA_T *state, bool on) { + // Publish state on /state topic and on/off led board + const char* message = on ? "On" : "Off"; + if (on) + cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1); + else + cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0); + + mqtt_publish(state->mqtt_client_inst, full_topic(state, "/led/state"), message, strlen(message), MQTT_PUBLISH_QOS, MQTT_PUBLISH_RETAIN, pub_request_cb, state); +} + +static void publish_temperature(MQTT_CLIENT_DATA_T *state) { + static float old_temperature; + const char *temperature_key = full_topic(state, "/temperature"); + float temperature = read_onboard_temperature(TEMPERATURE_UNITS); + if (temperature != old_temperature) { + old_temperature = temperature; + // Publish temperature on /temperature topic + char temp_str[16]; + snprintf(temp_str, sizeof(temp_str), "%.2f", temperature); + INFO_printf("Publishing %s to %s\n", temp_str, temperature_key); + mqtt_publish(state->mqtt_client_inst, temperature_key, temp_str, strlen(temp_str), MQTT_PUBLISH_QOS, MQTT_PUBLISH_RETAIN, pub_request_cb, state); + } +} + +static void sub_request_cb(void *arg, err_t err) { + MQTT_CLIENT_DATA_T* state = (MQTT_CLIENT_DATA_T*)arg; + if (err != 0) { + panic("subscribe request failed %d", err); + } + state->subscribe_count++; +} + +static void unsub_request_cb(void *arg, err_t err) { + MQTT_CLIENT_DATA_T* state = (MQTT_CLIENT_DATA_T*)arg; + if (err != 0) { + panic("unsubscribe request failed %d", err); + } + state->subscribe_count--; + assert(state->subscribe_count >= 0); + + // Stop if requested + if (state->subscribe_count <= 0 && state->stop_client) { + mqtt_disconnect(state->mqtt_client_inst); + } +} + +static void sub_unsub_topics(MQTT_CLIENT_DATA_T* state, bool sub) { + mqtt_request_cb_t cb = sub ? sub_request_cb : unsub_request_cb; + mqtt_sub_unsub(state->mqtt_client_inst, full_topic(state, "/led"), MQTT_SUBSCRIBE_QOS, cb, state, sub); + mqtt_sub_unsub(state->mqtt_client_inst, full_topic(state, "/print"), MQTT_SUBSCRIBE_QOS, cb, state, sub); + mqtt_sub_unsub(state->mqtt_client_inst, full_topic(state, "/ping"), MQTT_SUBSCRIBE_QOS, cb, state, sub); + mqtt_sub_unsub(state->mqtt_client_inst, full_topic(state, "/exit"), MQTT_SUBSCRIBE_QOS, cb, state, sub); +} + +static void mqtt_incoming_data_cb(void *arg, const u8_t *data, u16_t len, u8_t flags) { + MQTT_CLIENT_DATA_T* state = (MQTT_CLIENT_DATA_T*)arg; +#if MQTT_UNIQUE_TOPIC + const char *basic_topic = state->topic + strlen(state->mqtt_client_info.client_id) + 1; +#else + const char *basic_topic = state->topic; +#endif + strncpy(state->data, (const char *)data, len); + state->len = len; + state->data[len] = '\0'; + + DEBUG_printf("Topic: %s, Message: %s\n", state->topic, state->data); + if (strcmp(basic_topic, "/led") == 0) + { + if (lwip_stricmp((const char *)state->data, "On") == 0 || strcmp((const char *)state->data, "1") == 0) + control_led(state, true); + else if (lwip_stricmp((const char *)state->data, "Off") == 0 || strcmp((const char *)state->data, "0") == 0) + control_led(state, false); + } else if (strcmp(basic_topic, "/print") == 0) { + INFO_printf("%.*s\n", len, data); + } else if (strcmp(basic_topic, "/ping") == 0) { + char buf[11]; + snprintf(buf, sizeof(buf), "%u", to_ms_since_boot(get_absolute_time()) / 1000); + mqtt_publish(state->mqtt_client_inst, full_topic(state, "/uptime"), buf, strlen(buf), MQTT_PUBLISH_QOS, MQTT_PUBLISH_RETAIN, pub_request_cb, state); + } else if (strcmp(basic_topic, "/exit") == 0) { + state->stop_client = true; // stop the client when ALL subscriptions are stopped + sub_unsub_topics(state, false); // unsubscribe + } +} + +static void mqtt_incoming_publish_cb(void *arg, const char *topic, u32_t tot_len) { + MQTT_CLIENT_DATA_T* state = (MQTT_CLIENT_DATA_T*)arg; + strncpy(state->topic, topic, sizeof(state->topic)); +} + +static void temperature_worker_fn(async_context_t *context, async_at_time_worker_t *worker) { + MQTT_CLIENT_DATA_T* state = (MQTT_CLIENT_DATA_T*)worker->user_data; + publish_temperature(state); + async_context_add_at_time_worker_in_ms(context, worker, TEMP_WORKER_TIME_S * 1000); +} +static async_at_time_worker_t temperature_worker = { .do_work = temperature_worker_fn }; + +static void mqtt_connection_cb(mqtt_client_t *client, void *arg, mqtt_connection_status_t status) { + MQTT_CLIENT_DATA_T* state = (MQTT_CLIENT_DATA_T*)arg; + if (status == MQTT_CONNECT_ACCEPTED) { + state->connect_done = true; + sub_unsub_topics(state, true); // subscribe; + + // indicate online + if (state->mqtt_client_info.will_topic) { + mqtt_publish(state->mqtt_client_inst, state->mqtt_client_info.will_topic, "1", 1, MQTT_WILL_QOS, true, pub_request_cb, state); + } + + // Publish temperature every 10 sec if it's changed + temperature_worker.user_data = state; + async_context_add_at_time_worker_in_ms(cyw43_arch_async_context(), &temperature_worker, 0); + } else if (status == MQTT_CONNECT_DISCONNECTED) { + if (!state->connect_done) { + panic("Failed to connect to mqtt server"); + } + } + else { + panic("Unexpected status"); + } +} + +static void start_client(MQTT_CLIENT_DATA_T *state) { +#if LWIP_ALTCP && LWIP_ALTCP_TLS + const int port = MQTT_TLS_PORT; + INFO_printf("Using TLS\n"); +#else + const int port = MQTT_PORT; + INFO_printf("Warning: Not using TLS\n"); +#endif + + state->mqtt_client_inst = mqtt_client_new(); + if (!state->mqtt_client_inst) { + panic("MQTT client instance creation error"); + } + INFO_printf("IP address of this device %s\n", ipaddr_ntoa(&(netif_list->ip_addr))); + INFO_printf("Connecting to mqtt server at %s\n", ipaddr_ntoa(&state->mqtt_server_address)); + + cyw43_arch_lwip_begin(); + if (mqtt_client_connect(state->mqtt_client_inst, &state->mqtt_server_address, port, mqtt_connection_cb, state, &state->mqtt_client_info) != ERR_OK) { + panic("MQTT broker connection error"); + } +#if LWIP_ALTCP && LWIP_ALTCP_TLS + // This is important for MBEDTLS_SSL_SERVER_NAME_INDICATION + mbedtls_ssl_set_hostname(altcp_tls_context(state->mqtt_client_inst->conn), MQTT_SERVER); +#endif + mqtt_set_inpub_callback(state->mqtt_client_inst, mqtt_incoming_publish_cb, mqtt_incoming_data_cb, state); + cyw43_arch_lwip_end(); +} + +// Call back with a DNS result +static void dns_found(const char *hostname, const ip_addr_t *ipaddr, void *arg) { + MQTT_CLIENT_DATA_T *state = (MQTT_CLIENT_DATA_T*)arg; + if (ipaddr) { + state->mqtt_server_address = *ipaddr; + start_client(state); + } else { + panic("dns request failed"); + } +} + +int main(void) { + stdio_init_all(); + INFO_printf("mqtt client starting\n"); + + adc_init(); + adc_set_temp_sensor_enabled(true); + adc_select_input(4); + + static MQTT_CLIENT_DATA_T state; + + if (cyw43_arch_init()) { + panic("Failed to inizialize CYW43"); + } + + // Use board unique id + char unique_id_buf[5]; + pico_get_unique_board_id_string(unique_id_buf, sizeof(unique_id_buf)); + for(int i=0; i < sizeof(unique_id_buf) - 1; i++) { + unique_id_buf[i] = tolower(unique_id_buf[i]); + } + + // Generate a unique name, e.g. pico1234 + char client_id_buf[sizeof(MQTT_DEVICE_NAME) + sizeof(unique_id_buf) - 1]; + memcpy(&client_id_buf[0], MQTT_DEVICE_NAME, sizeof(MQTT_DEVICE_NAME) - 1); + memcpy(&client_id_buf[sizeof(MQTT_DEVICE_NAME) - 1], unique_id_buf, sizeof(unique_id_buf) - 1); + client_id_buf[sizeof(client_id_buf) - 1] = 0; + INFO_printf("Device name %s\n", client_id_buf); + + state.mqtt_client_info.client_id = client_id_buf; + state.mqtt_client_info.keep_alive = MQTT_KEEP_ALIVE_S; // Keep alive in sec +#if defined(MQTT_USERNAME) && defined(MQTT_PASSWORD) + state.mqtt_client_info.client_user = MQTT_USERNAME; + state.mqtt_client_info.client_pass = MQTT_PASSWORD; +#else + state.mqtt_client_info.client_user = NULL; + state.mqtt_client_info.client_pass = NULL; +#endif + static char will_topic[MQTT_TOPIC_LEN]; + strncpy(will_topic, full_topic(&state, MQTT_WILL_TOPIC), sizeof(will_topic)); + state.mqtt_client_info.will_topic = will_topic; + state.mqtt_client_info.will_msg = MQTT_WILL_MSG; + state.mqtt_client_info.will_qos = MQTT_WILL_QOS; + state.mqtt_client_info.will_retain = true; +#if LWIP_ALTCP && LWIP_ALTCP_TLS + // TLS enabled +#ifdef MQTT_CERT_INC + static const uint8_t ca_cert[] = TLS_ROOT_CERT; + static const uint8_t client_key[] = TLS_CLIENT_KEY; + static const uint8_t client_cert[] = TLS_CLIENT_CERT; + // This confirms the indentity of the server and the client + state.mqtt_client_info.tls_config = altcp_tls_create_config_client_2wayauth(ca_cert, sizeof(ca_cert), + client_key, sizeof(client_key), NULL, 0, client_cert, sizeof(client_cert)); +#if ALTCP_MBEDTLS_AUTHMODE != MBEDTLS_SSL_VERIFY_REQUIRED + WARN_printf("Warning: tls without verification is insecure\n"); +#endif +#else + state->client_info.tls_config = altcp_tls_create_config_client(NULL, 0); + WARN_printf("Warning: tls without a certificate is insecure\n"); +#endif +#endif + + cyw43_arch_enable_sta_mode(); + if (cyw43_arch_wifi_connect_timeout_ms(WIFI_SSID, WIFI_PASSWORD, CYW43_AUTH_WPA2_AES_PSK, 30000)) { + panic("Failed to connect"); + } + INFO_printf("\nConnected to Wifi\n"); + + // We are not in a callback so locking is needed when calling lwip + // Make a DNS request for the MQTT server IP address + cyw43_arch_lwip_begin(); + int err = dns_gethostbyname(MQTT_SERVER, &state.mqtt_server_address, dns_found, &state); + cyw43_arch_lwip_end(); + + if (err == ERR_OK) { + // We have the address, just start the client + start_client(&state); + } else if (err != ERR_INPROGRESS) { // ERR_INPROGRESS means expect a callback + panic("dns request failed"); + } + + while (!state.connect_done || mqtt_client_is_connected(state.mqtt_client_inst)) { + cyw43_arch_poll(); + cyw43_arch_wait_for_work_until(make_timeout_time_ms(10000)); + } + + INFO_printf("mqtt client exiting\n"); + return 0; +}