1  #include <stdio.h>
  2  #include <string.h>
  3  #include <pthread.h>
  4  #include <stdlib.h>
  5  #include <unistd.h>
  6  #include "esp32_compat.h"
  7  
  8  void*     g_queue;
  9  int       g_queue_send_shall_fail = 0;
 10  int       g_size = 0;
 11  
 12  const char * WIFI_EVENT = "wifi_event";
 13  const char * ETH_EVENT = "eth_event";
 14  
 15  esp_err_t esp_event_handler_register(const char * event_base,
 16                                          int32_t event_id,
 17                                          void* event_handler,
 18                                          void* event_handler_arg)
 19  {
 20      return ESP_OK;
 21  }
 22  
 23  esp_err_t esp_event_handler_unregister(const char * event_base, int32_t event_id, void* event_handler)
 24  {
 25      return ESP_OK;
 26  }
 27  
 28  esp_err_t esp_timer_delete(esp_timer_handle_t timer)
 29  {
 30      return ESP_OK;
 31  }
 32  
 33  esp_err_t esp_timer_stop(esp_timer_handle_t timer)
 34  {
 35      return ESP_OK;
 36  }
 37  
 38  esp_err_t esp_timer_start_periodic(esp_timer_handle_t timer, uint64_t period)
 39  {
 40      return ESP_OK;
 41  }
 42  
 43  esp_err_t esp_timer_create(const esp_timer_create_args_t* create_args,
 44                             esp_timer_handle_t* out_handle)
 45  {
 46      return ESP_OK;
 47  }
 48  
 49  uint32_t xTaskGetTickCount(void)
 50  {
 51      struct timeval tv;
 52      struct timezone tz;
 53      if (gettimeofday(&tv, &tz) == 0) {
 54          return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
 55      }
 56      return 0;
 57  }
 58  
 59  /// Queue mock
 60   QueueHandle_t xQueueCreate( uint32_t uxQueueLength, uint32_t uxItemSize )
 61   {
 62       g_size = uxItemSize;
 63       g_queue = malloc((uxQueueLength)*(uxItemSize));
 64       return g_queue;
 65   }
 66  
 67  
 68  void vQueueDelete( QueueHandle_t xQueue )
 69  {
 70      free(xQueue);
 71  }
 72  
 73  uint32_t xQueueSend(QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait)
 74  {
 75      if (g_queue_send_shall_fail)
 76      {
 77          return pdFALSE;
 78      }
 79      else
 80      {
 81          memcpy(xQueue, pvItemToQueue, g_size);
 82          return pdPASS;
 83      }
 84  }
 85  
 86  
 87  uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait)
 88  {
 89      return pdFALSE;
 90  }
 91  
 92  void GetLastItem(void *pvBuffer)
 93  {
 94      memcpy(pvBuffer, g_queue, g_size);
 95  }
 96  
 97  void ForceTaskDelete(void)
 98  {
 99      g_queue_send_shall_fail = 1;
100  }