pppos_esp

#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "tcpip_adapter.h"
#include "mqtt_client.h"
#include "esp_log.h"
#include "sim800.h"
#include "bg96.h"
#include "esp_modem.h"

#if CONFIG_BROKER_CERTIFICATE_OVERRIDDEN == 1
static const uint8_t letsencrypt_pem_start[]  = "-----BEGIN CERTIFICATE-----\n" CONFIG_BROKER_CERTIFICATE_OVERRIDE "\n-----END CERTIFICATE-----";
#else
extern const uint8_t letsencrypt_pem_start[]   asm("_binary_letsencrypt_pem_start");
#endif
extern const uint8_t letsencrypt_pem_end[] asm("_binary_letsencrypt_pem_end");

static const char *TAG = "pppos_example";
static EventGroupHandle_t event_group = NULL;
static const int CONNECT_BIT = BIT0;
static const int STOP_BIT = BIT1;
static const int GOT_DATA_BIT = BIT2;
esp_mqtt_client_handle_t mqtt_client;
TaskHandle_t xSpamHandle = NULL;
modem_dte_t *dte = NULL;
modem_dce_t *dce = NULL;


void spam(void *);
void gsm_start(int);

uint64_t get_time_millis(){
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return (uint64_t) tv.tv_sec * 1000ULL + ((uint64_t) tv.tv_usec / 1000ULL);
}

static void modem_event_handler(void *event_handler_arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
{
    switch (event_id) {
    case MODEM_EVENT_PPP_START:
        ESP_LOGI(TAG, "Modem PPP Started");
        break;
    case MODEM_EVENT_PPP_CONNECT:
        ESP_LOGI(TAG, "Modem Connect to PPP Server");
        ppp_client_ip_info_t *ipinfo = (ppp_client_ip_info_t *)(event_data);
        ESP_LOGI(TAG, "~~~~~~~~~~~~~~");
        ESP_LOGI(TAG, "IP          : " IPSTR, IP2STR(&ipinfo->ip));
        ESP_LOGI(TAG, "Netmask     : " IPSTR, IP2STR(&ipinfo->netmask));
        ESP_LOGI(TAG, "Gateway     : " IPSTR, IP2STR(&ipinfo->gw));
        ESP_LOGI(TAG, "Name Server1: " IPSTR, IP2STR(&ipinfo->ns1));
        ESP_LOGI(TAG, "Name Server2: " IPSTR, IP2STR(&ipinfo->ns2));
        ESP_LOGI(TAG, "~~~~~~~~~~~~~~");
        xEventGroupSetBits(event_group, CONNECT_BIT);
        break;
    case MODEM_EVENT_PPP_DISCONNECT:
        ESP_LOGI(TAG, "Modem Disconnect from PPP Server");
        break;
    case MODEM_EVENT_PPP_STOP:
        ESP_LOGI(TAG, "Modem PPP Stopped");
        xEventGroupSetBits(event_group, STOP_BIT);
        break;
    case MODEM_EVENT_UNKNOWN:
        ESP_LOGW(TAG, "Unknow line received: %s", (char *)event_data);
        break;
    default:
      ESP_LOGW("MODEM:", "Unknown event_id: %d", event_id);
        break;
    }
}

static esp_err_t mqtt_event_handler(esp_mqtt_event_handle_t event)
{
    esp_mqtt_client_handle_t client = event->client;
    int msg_id;
    switch (event->event_id) {
    case MQTT_EVENT_CONNECTED://
        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
        msg_id = esp_mqtt_client_subscribe(client, "/topic/esp-pppos", 0);
        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
        xTaskCreate(spam, "SPAM_MQTT", 10000, NULL, 10, &xSpamHandle);
        break;
    case MQTT_EVENT_DISCONNECTED:
      //restart PPPoS
        ESP_LOGI("SPAM", "setup ppp, DCE: %x, DTE: %x", (int ) dce, (int)dte);
        gsm_start(1);
        /* gsm_start(); */
        /* esp_modem_exit_ppp(dte); */
        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
        break;
    case MQTT_EVENT_SUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
        uint64_t asd = get_time_millis();
        char msg[20];
        sprintf(msg, "%lld", asd);
        msg_id = esp_mqtt_client_publish(client, "/topic/esp-pppos", msg , 0, 0, 0);
        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
        break;
    case MQTT_EVENT_UNSUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_DATA:
        ESP_LOGI(TAG, "MQTT_EVENT_DATA");
        printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
        printf("DATA=%.*s\r\n", event->data_len, event->data);
        /* xEventGroupSetBits(event_group, GOT_DATA_BIT); */
        break;
    case MQTT_EVENT_ERROR:
        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
        break;
    default://before conencted
      /* esp_modem_setup_ppp(dte); */
        ESP_LOGI(TAG, "MQTT other event id: %d", event->event_id);
        break;
    }
    return ESP_OK;
}

void spam(void * params){
  int counter = 0;
  while(1){
    vTaskDelay(500);
    if(dce != NULL){
      ESP_LOGI("SPAM", "STATE_ENUM: %d", dce->state);
    }else{
      ESP_LOGI("SPAM", "IS NULL.. new init");
      gsm_start(1);
    }
    counter++;
    char buff[20];
    sprintf(buff, "nr: %d", counter);
    esp_mqtt_client_publish(mqtt_client, "/topic/test", buff, 0, 1, 0);
  }
}

void gsm_start(int restart){
  /* create dte object */
  if(dte==NULL){
    esp_modem_dte_config_t config = ESP_MODEM_DTE_DEFAULT_CONFIG();
    config.flow_control = MODEM_FLOW_CONTROL_SW;
    dte = esp_modem_dte_init(&config);
    /* Register event handler */
    ESP_ERROR_CHECK(esp_modem_add_event_handler(dte, modem_event_handler, NULL));
  }
  /* create dce object */
  dce = sim800_init(dte);
  if(dce==NULL) return;
  ESP_LOGI(TAG, "Module: %s", dce->name);
  ESP_LOGI(TAG, "Operator: %s", dce->oper);
  ESP_LOGI(TAG, "IMEI: %s", dce->imei);
  ESP_LOGI(TAG, "IMSI: %s", dce->imsi);
  uint32_t rssi = 0, ber = 0;
  ESP_ERROR_CHECK(dce->get_signal_quality(dce, &rssi, &ber));
  ESP_LOGI(TAG, "rssi: %d, ber: %d", rssi, ber);
  /* Get battery voltage */
  uint32_t voltage = 0, bcs = 0, bcl = 0;
  ESP_ERROR_CHECK(dce->get_battery_status(dce, &bcs, &bcl, &voltage));
  ESP_LOGI(TAG, "Battery voltage: %d mV", voltage);

  esp_modem_setup_ppp(dte);
  /* Wait for IP address */
  xEventGroupWaitBits(event_group, CONNECT_BIT, pdTRUE, pdTRUE, portMAX_DELAY);
}

void app_main()
{
    tcpip_adapter_init();
    event_group = xEventGroupCreate();

    /* /\* create dte object *\/ */
    gsm_start(1);

    /* Config MQTT */
    esp_mqtt_client_config_t mqtt_config = {
                                            .uri = CONFIG_BROKER_URL,
                                            .event_handle = mqtt_event_handler,
                                            .cert_pem = (const char *)letsencrypt_pem_start,
                                            .disable_clean_session = true,
                                            .keepalive = 5,
    };
    mqtt_client = esp_mqtt_client_init(&mqtt_config);
    esp_mqtt_client_start(mqtt_client);


    xEventGroupWaitBits(event_group, GOT_DATA_BIT, pdTRUE, pdTRUE, portMAX_DELAY);
    esp_mqtt_client_destroy(mqtt_client);
    /* Exit PPP mode */
    ESP_ERROR_CHECK(esp_modem_exit_ppp(dte));
    xEventGroupWaitBits(event_group, STOP_BIT, pdTRUE, pdTRUE, portMAX_DELAY);
#if CONFIG_SEND_MSG
    const char *message = "Welcome to ESP32!";
    ESP_ERROR_CHECK(example_send_message_text(dce, CONFIG_SEND_MSG_PEER_PHONE_NUMBER, message));
    ESP_LOGI(TAG, "Send send message [%s] ok", message);
#endif
    /* Power down module */
    ESP_ERROR_CHECK(dce->power_down(dce));
    ESP_LOGI(TAG, "Power down");
    ESP_ERROR_CHECK(dce->deinit(dce));
    ESP_ERROR_CHECK(dte->deinit(dte));
}