ESP-IDF and type corrections

Author: nicklasb

components/robusto/conductor/Kconfig

@@ -71,9 +71,10 @@ menu "Conductor configuration"
                 hex "The MAC-address of the conductor, a 6-byte hex value"
                 depends on !ROBUSTO_CONDUCTOR_CLIENT_CONDUCTOR_MEDIA_I2C
                 range 0x000000000000 0xFFFFFFFFFFFF
+                default 0x000000000000
                 help
                     This is the MAC-address of the conductor
-                    Write it as a large hexadecimal number, for example 0x01AB11BB12BC (6*8 bits)
+                    Write it as a large hexadecimal number, for example 0x01AB11BB12BC : 6*8 bits
 
             config ROBUSTO_CONDUCTOR_RETRY_WAIT_S
                 int "Retry delay"

components/robusto/conductor/src/robusto_conductor_client.c

@@ -33,7 +33,7 @@ static network_service_t conductor_client_service = {
     .service_name = "Conductor client service",
     .incoming_callback = &on_incoming_conductor_client,
     .service_id = ROBUSTO_CONDUCTOR_CLIENT_SERVICE_ID,
-    .shutdown_callback = &on_shutting_down_conductor_client,
+    .shutdown_callback = (shutdown_cb *)&on_shutting_down_conductor_client,
 };
 
 void on_shutting_down_conductor_client(robusto_message_t *message)
@@ -163,7 +163,7 @@ void robusto_add_conductor() {
             main_conductor_peer = add_peer_by_i2c_address("CONDUCTOR_MAIN", CONFIG_ROBUSTO_CONDUCTOR_CLIENT_CONDUCTOR_I2C_ADDRESS)
         }
     #else
-        main_conductor_peer = robusto_peers_find_peer_by_base_mac_address(kconfig_mac_to_6_bytes(CONFIG_ROBUSTO_CONDUCTOR_CLIENT_CONDUCTOR_MAC_ADDRESS));
+        main_conductor_peer = robusto_peers_find_peer_by_base_mac_address((rob_mac_address *)kconfig_mac_to_6_bytes(CONFIG_ROBUSTO_CONDUCTOR_CLIENT_CONDUCTOR_MAC_ADDRESS));
         if (!main_conductor_peer) {
             main_conductor_peer = add_peer_by_mac_address("CONDUCTOR_MAIN", kconfig_mac_to_6_bytes(CONFIG_ROBUSTO_CONDUCTOR_CLIENT_CONDUCTOR_MAC_ADDRESS), media_type);
         }

components/robusto/conductor/src/robusto_conductor_server.c

@@ -47,7 +47,7 @@ static network_service_t conductor_server_service = {
     .service_name = "Conductor server service",
     .incoming_callback = &on_incoming_conductor_server,
     .service_id = ROBUSTO_CONDUCTOR_SERVER_SERVICE_ID,
-    .shutdown_callback = &on_shutting_down_conductor_server,
+    .shutdown_callback = (shutdown_cb *) &on_shutting_down_conductor_server,
 };
 
 void on_shutting_down_conductor_server(robusto_message_t *message)

components/robusto/include/robusto_message.h

@@ -208,7 +208,7 @@ fragmented_message_t * get_last_frag_message();
  * @param receipt Wait for a receipt
  * @return typedef The return value
  */
-typedef rob_ret_val_t cb_send_message(robusto_peer_t *peer, const uint8_t *data, int len, bool receipt);
+typedef rob_ret_val_t cb_send_message(robusto_peer_t *peer, uint8_t *data, uint32_t len, bool receipt);
 
 /**
  * @brief Handle incoming fragmented messaged
@@ -222,7 +222,7 @@ typedef rob_ret_val_t cb_send_message(robusto_peer_t *peer, const uint8_t *data,
  * @return If true, send receipt (used in initialisation, but not with parts)
  */
 
-bool handle_fragmented(robusto_peer_t *peer, e_media_type media_type, const uint8_t *data, int len, uint32_t fragment_size, cb_send_message * send_message);
+bool handle_fragmented(robusto_peer_t *peer, e_media_type media_type, uint8_t *data, int len, uint32_t fragment_size, cb_send_message * send_message);
 
 
 /**

components/robusto/misc/src/pubsub/robusto_pubsub_client.c

@@ -323,7 +323,7 @@ subscribed_topic_t *robusto_pubsub_client_get_topic(robusto_peer_t *peer, char *
 void recover_topic(subscribed_topic_t *topic)
 {
     robusto_pubsub_client_get_topic(topic->peer, topic->topic_name, topic->callback, topic->display_offset);
-    if (topic->state == TOPIC_STATE_PROBLEM && !robusto_waitfor_byte_change(&topic->state, 1000) != ROB_OK)
+    if (topic->state == TOPIC_STATE_PROBLEM && !robusto_waitfor_byte_change((uint8_t *)&topic->state, 1000) != ROB_OK)
     {
         ROB_LOGE(pubsub_client_log_prefix, "Failed to recover %s using the %s peer", topic->topic_name, topic->peer->name);
         topic->state = TOPIC_STATE_PROBLEM;
@@ -353,7 +353,7 @@ void create_topic_recovery_task(subscribed_topic_t *topic)
              topic->topic_name, topic->peer->name);
     char *task_name;
     robusto_asprintf(&task_name, "Recovery task task for %s topic, peer %s", topic->topic_name, topic->peer->name);
-    if (robusto_create_task(&recover_topic, topic, task_name, NULL, 0) != ROB_OK)
+    if (robusto_create_task((TaskFunction_t)&recover_topic, topic, task_name, NULL, 0) != ROB_OK)
     {
         ROB_LOGE(pubsub_client_log_prefix, "Failed creating a recovery task for %s topic, peer %s", topic->topic_name, topic->peer->name);
     }

components/robusto/misc/src/pubsub/robusto_pubsub_server.c

@@ -135,7 +135,7 @@ uint32_t robusto_pubsub_server_unsubscribe(robusto_peer_t *peer, pubsub_server_s
     return ROB_OK;
 }
 
-rob_ret_val_t publish_topic(pubsub_server_topic_t * topic, pubsub_server_subscriber_t *subscriber, uint* data, int data_length) {
+rob_ret_val_t publish_topic(pubsub_server_topic_t * topic, pubsub_server_subscriber_t *subscriber, uint8_t* data, int data_length) {
     if (subscriber->local_callback) {
         ROB_LOGI(pubsub_log_prefix, "Publishing %s to callback", topic->name);
         subscriber->local_callback(data, data_length);

components/robusto/misc/src/umts/Kconfig

@@ -6,6 +6,7 @@ config ROBUSTO_UMTS_SERVER
             The UMTS gateway allows access to the cellular network and presents two services:
             1. Sending MQTT messages to a predefined server
             2. Sending SMS messages to a specified recipient
+            Note: Needs ROBUSTO_UMTS_SERVER to be enabled.
 
     menu "UMTS gateway configuration"
         depends on ROBUSTO_UMTS_SERVER

components/robusto/misc/src/umts/robusto_umts.c

@@ -136,7 +136,7 @@ void robusto_umts_init(char *_log_prefix)
     umts_event_group = xEventGroupCreate();
     xEventGroupClearBits(umts_event_group, GSM_CONNECT_BIT | GSM_GOT_DATA_BIT | GSM_SHUTTING_DOWN_BIT);
 
-    umts_init_queue(&umts_do_on_work_cb, umts_log_prefix);
+    umts_init_queue((work_callback *)&umts_do_on_work_cb, umts_log_prefix);
 
     ROB_LOGI(umts_log_prefix, "* Registering GSM main task...");
     int rc = xTaskCreatePinnedToCore((TaskFunction_t)robusto_umts_start, "UMTS main task", /*8192*/ /*16384*/ 32768,

components/robusto/misc/src/umts/robusto_umts_ip.c

@@ -4,6 +4,11 @@
 #include "freertos/event_groups.h"
 
 #include <esp_netif.h>
+
+#ifndef CONFIG_PPP_SUPPORT
+#error "The Robusto UMTS server requires PPP support. Please enable CONFIG_PPP_SUPPORT."
+#endif
+
 #include <esp_netif_ppp.h>
 
 #include <esp_modem_api.h>

components/robusto/misc/src/umts/robusto_umts_queue.c

@@ -26,7 +26,7 @@ static char *umts_queue_log_prefix;
 STAILQ_HEAD(umts_work_q, umts_queue_item) umts_work_q;
 
 struct umts_queue_item_t *umts_first_queueitem() {
-    return STAILQ_FIRST(&umts_work_q); 
+    return (struct umts_queue_item_t *) STAILQ_FIRST(&umts_work_q); 
 }
 
 
@@ -38,13 +38,14 @@ void umts_insert_tail(umts_queue_item_t *new_item) {
 }
 
 rob_ret_val_t umts_safe_add_work_queue(umts_queue_item_t *new_item) {   
-    return safe_add_work_queue(&umts_queue_context, new_item);
+    return safe_add_work_queue(&umts_queue_context, new_item, false);
 }
 void umts_cleanup_queue_task(umts_queue_item_t *queue_item) {
     if (queue_item != NULL)
     {
-        robusto_message_free(queue_item->topic);
-        robusto_message_free(queue_item->data);
+        robusto_free(queue_item->topic);
+        robusto_free(queue_item->data);
+        robusto_free(queue_item->state);
         robusto_free(queue_item);
     }
     cleanup_queue_task(&umts_queue_context);
@@ -65,9 +66,9 @@ rob_ret_val_t umts_init_queue(work_callback work_cb, char *_log_prefix)
     // Initialize the work queue
     STAILQ_INIT(&umts_work_q);
 
-    umts_queue_context.first_queue_item_cb = &umts_first_queueitem; 
-    umts_queue_context.remove_first_queueitem_cb = &umts_remove_first_queue_item; 
-    umts_queue_context.insert_tail_cb = &umts_insert_tail;
+    umts_queue_context.first_queue_item_cb = (first_queueitem *)&umts_first_queueitem; 
+    umts_queue_context.remove_first_queueitem_cb = (remove_first_queueitem *)&umts_remove_first_queue_item; 
+    umts_queue_context.insert_tail_cb = (insert_queue_item *)&umts_insert_tail;
     umts_queue_context.insert_head_cb = NULL;
     umts_queue_context.on_work_cb = work_cb; 
     umts_queue_context.max_task_count = 1;