HELPDESK_WJ (Waijung)

/*

 * File: esp32_mesh_ROBOR2.c

 *

 * Code generated with Waijung 2 ESP32 Target Blockset,

 * for Simulink model 'esp32_mesh_ROBOR2'.

 *

 * Model version                  : 1.67

 * Simulink Coder version         : 9.3 (R2020a) 18-Nov-2019

 * C/C++ source code generated on : Sun Jul 18 12:49:51 2021

 *

 * Target selection: esp32.tlc

 * Embedded hardware selection: Cadence Design Systems (Tensilica)->Xtensa? single-/dual-core 32-bit LX6 microprocessor

 * Code generation objectives: Unspecified

 * Validation result: Not run

 */

#include "esp32_mesh_ROBOR2.h"

#include "esp32_mesh_ROBOR2_private.h"

/* Block signals (default storage) */

B_esp32_mesh_ROBOR2_T esp32_mesh_ROBOR2_B;

/* Block states (default storage) */

DW_esp32_mesh_ROBOR2_T esp32_mesh_ROBOR2_DW;

/* Real-time model */

RT_MODEL_esp32_mesh_ROBOR2_T esp32_mesh_ROBOR2_M_;

RT_MODEL_esp32_mesh_ROBOR2_T *const esp32_mesh_ROBOR2_M = &esp32_mesh_ROBOR2_M_;

/* Model step function */

void esp32_mesh_ROBOR2_step(void)

{

  /* S-Function (esp32_wifi_mesh): '<Root>/MESH Receive' */

  /* MESHReceive: '<Root>/MESH Receive'

   */

  {

    if (is_mesh_connected) {

      //memcpy(sql_buffer,

      //jsonbuffer[0]='\0';

      //db_start

      //jsonbuffer[strlen(jsonbuffer)-1]= '\0';

      //memcpy(

      int flag = 0;

      recv_data.data = rx_buf;

      recv_data.size = RX_SIZE;

      err = esp_mesh_recv(&from, &recv_data, 1000, &flag , NULL, 0);

      if (err != ESP_OK || !recv_data.size) {

        // ESP_LOGE(MESH_TAG, "err:0x%x, size:%d", err, recv_data.size);

        // rx_buf[0]='\0';

        sprintf(&mesh_recv_from[0],""MACSTR"",MAC2STR(from.addr));

        received= false;

      }

      if (err == ESP_OK) {

        received= true;

        printf("In ESP_OK\n");

        sprintf(&mesh_recv_from[0],""MACSTR"",MAC2STR(from.addr));

        //sprintf(&mesh_from[0],""MACSTR"",MAC2STR(from.addr));

      }

      mesh_recv_init= true;

      if (received) {

        memcpy(&esp32_mesh_ROBOR2_B.MESHReceive_o1[0], rx_buf, 32);

        memcpy(&esp32_mesh_ROBOR2_B.MESHReceive_o2[0], (uint8_t *)mesh_recv_from,

               strlen(mesh_recv_from));

      } else {

        memset(&taskTest_B.MESH2_o1[0], 0, 32);

        memset(&taskTest_B.MESH2_o2[0], 0, strlen(mesh_recv_from));

      }

    }

  }

  /* S-Function (waijung2_string_processing): '<Root>/String Processing' */

  /* StringProcessing: '<Root>/String Processing' */

  waijung2_sprintf_s((char *)&esp32_mesh_ROBOR2_B.StringProcessing[0], 32,

                     "\r\nData= %s" , (char *)

                     &esp32_mesh_ROBOR2_B.MESHReceive_o1[0] );

  /* S-Function (waijung2_string_processing): '<Root>/String Processing1' */

  /* StringProcessing1: '<Root>/String Processing1' */

  waijung2_sprintf_s((char *)&esp32_mesh_ROBOR2_B.StringProcessing1[0], 32,

                     "From= %s" , (char *)&esp32_mesh_ROBOR2_B.MESHReceive_o2[0]

                     );

  /* S-Function (waijung2_string_processing): '<Root>/String Processing3' incorporates:

   *  Constant: '<Root>/Constant'

   *  Constant: '<Root>/Constant1'

   */

  /* StringProcessing3: '<Root>/String Processing3' */

  waijung2_sprintf_s((char *)&esp32_mesh_ROBOR2_B.StringProcessing3[0], 64,

                     "%c%c%s, %s" , (int8_t)((uint8_T)13U) , (int8_t)((uint8_T)

    10U) , (char *)&esp32_mesh_ROBOR2_B.StringProcessing[0] , (char *)

                     &esp32_mesh_ROBOR2_B.StringProcessing1[0] );

  /* S-Function (waijung2_string_processing): '<Root>/String Processing2' */

  /* StringProcessing2: '<Root>/String Processing2' */

  {

    uint32_T len = 0;

    const uint8_T *data = &esp32_mesh_ROBOR2_B.StringProcessing3[0];

    while ((data[len] != '\0') && (len<64))

      len++;

    esp32_mesh_ROBOR2_B.StringProcessing2 = len;

  }

  /* DataTypeConversion: '<Root>/Data Type Conversion' */

  esp32_mesh_ROBOR2_B.DataTypeConversion = (uint16_T)

    esp32_mesh_ROBOR2_B.StringProcessing2;

  /* S-Function (esp32_uart): '<Root>/UART Tx1' */

  /* UARTTx1: '<Root>/UART Tx1'

   * Packet: Raw Buffer

   */

  {

    uint16_t len = esp32_mesh_ROBOR2_B.DataTypeConversion;

    if (len > 64)

      len = 64;

    UART0_Write (UART_NUM_0,(uint8_t *)&esp32_mesh_ROBOR2_B.StringProcessing3[0],

                 len);

  }

  /* DiscretePulseGenerator: '<Root>/Pulse Generator' */

  esp32_mesh_ROBOR2_B.PulseGenerator = ((esp32_mesh_ROBOR2_DW.clockTickCounter <

    250) && (esp32_mesh_ROBOR2_DW.clockTickCounter >= 0));

  if (esp32_mesh_ROBOR2_DW.clockTickCounter >= 499) {

    esp32_mesh_ROBOR2_DW.clockTickCounter = 0;

  } else {

    esp32_mesh_ROBOR2_DW.clockTickCounter++;

  }

  /* End of DiscretePulseGenerator: '<Root>/Pulse Generator' */

  /* S-Function (esp32_digital_output3): '<Root>/Digital Out' */

  /* Updating the pins of DigitalOut */

  gpio_set_level(33,(uint32_t) esp32_mesh_ROBOR2_B.PulseGenerator);/* GPIO33 */

  /* S-Function (esp32_wifi_mesh): '<Root>/MESH Setup' */

  /* MESHSetup: '<Root>/MESH Setup'

   */

  {

    esp32_mesh_ROBOR2_B.MESHSetup = (int)is_mesh_connected;

    if (is_mesh_connected) {

      //memcpy(sql_buffer,

      //jsonbuffer[0]='\0';

      //db_start

      //jsonbuffer[strlen(jsonbuffer)-1]= '\0';

      //memcpy(

    }

  }

}

/* Model initialize function */

void esp32_mesh_ROBOR2_initialize(void)

{

  /* Registration code */

  /* initialize error status */

  rtmSetErrorStatus(esp32_mesh_ROBOR2_M, (NULL));

  /* block I/O */

  (void) memset(((void *) &esp32_mesh_ROBOR2_B), 0,

                sizeof(B_esp32_mesh_ROBOR2_T));

  /* states (dwork) */

  (void) memset((void *)&esp32_mesh_ROBOR2_DW, 0,

                sizeof(DW_esp32_mesh_ROBOR2_T));

  /* Start for DiscretePulseGenerator: '<Root>/Pulse Generator' */

  esp32_mesh_ROBOR2_DW.clockTickCounter = 0;

  /* Start for S-Function (esp32_digital_output3): '<Root>/Digital Out' */

  //================================================================= GPIO Out pins: 'DigitalOut' Initialization

  //GPIO_initialize_DigitalOut();

  /* Start for S-Function (esp32_wifi_mesh): '<Root>/MESH Setup' */

  get_board_uuid();

  ESP_ERROR_CHECK(nvs_flash_init());

  /*  tcpip initialization */

  tcpip_adapter_init();

  /* for mesh

   * stop DHCP server on softAP interface by default

   * stop DHCP client on station interface by default

   * */

  ESP_ERROR_CHECK(tcpip_adapter_dhcps_stop(TCPIP_ADAPTER_IF_AP));

  ESP_ERROR_CHECK(tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA));

  /*  event initialization */

  ESP_ERROR_CHECK(esp_event_loop_create_default());

  /*  wifi initialization */

  wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();

  ESP_ERROR_CHECK(esp_wifi_init(&config));

  ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP,

    &ip_event_handler, NULL));

  ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH));

  ESP_ERROR_CHECK(esp_wifi_start());

  /*  mesh initialization */

  ESP_ERROR_CHECK(esp_mesh_init());

  ESP_ERROR_CHECK(esp_event_handler_register(MESH_EVENT, ESP_EVENT_ANY_ID,

    &mesh_event_handler, NULL));

  ESP_ERROR_CHECK(esp_mesh_set_max_layer(6));

  ESP_ERROR_CHECK(esp_mesh_set_vote_percentage(1));

  ESP_ERROR_CHECK(esp_mesh_set_ap_assoc_expire(10));

  mesh_cfg_t cfg = MESH_INIT_CONFIG_DEFAULT();

  /* mesh ID */

  memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6);

  /* router */

  char routerssid[20]= "BeMyGuest";

  char passwrd[20]= "";

  cfg.channel = 13;

  cfg.router.ssid_len = strlen(routerssid);

  memcpy((uint8_t *) &cfg.router.ssid, routerssid, cfg.router.ssid_len);

  memcpy((uint8_t *) &cfg.router.password, passwrd,

         strlen(passwrd));

  /* mesh softAP */

  ESP_ERROR_CHECK(esp_mesh_set_ap_authmode(WIFI_AUTH_WPA2_PSK));

  cfg.mesh_ap.max_connection = 6;

  memcpy((uint8_t *) &cfg.mesh_ap.password, "MESH1234",

         strlen("MESH1234"));

  ESP_ERROR_CHECK(esp_mesh_set_config(&cfg));

  /* mesh start */

  ESP_ERROR_CHECK(esp_mesh_start());

  ESP_LOGI(MESH_TAG, "mesh starts successfully, heap:%d, %s\n",

           esp_get_free_heap_size(),

           esp_mesh_is_root_fixed() ? "root fixed" : "root not fixed");

  // xTaskCreate(esp_mesh_p2p_rx_main, "MPRX", 5120, NULL, 5, NULL);

  /* Enable for S-Function (esp32_uart): '<Root>/UART Tx1' */

  /* Level2 S-Function Block: '<Root>/UART Tx1' (esp32_uart) */

  enable_UARTTx1();

  /* Enable for S-Function (esp32_digital_output3): '<Root>/Digital Out' */

  /* Level2 S-Function Block: '<Root>/Digital Out' (esp32_digital_output3) */

  GPIO_initialize_DigitalOut();

  /* Enable for S-Function (esp32_uart): '<Root>/UART Setup' */

  /* Level2 S-Function Block: '<Root>/UART Setup' (esp32_uart) */

  enable_UARTSetup();

  /* ConstCode for S-Function (esp32_wifi_mesh): '<Root>/MESH Send' */

  /* MESHSend: '<Root>/MESH Send'

   */

  {

    if (is_mesh_connected) {

      memcpy(mesh_from,&esp32_mesh_ROBOR2_ConstB.StringtoASCII[0],31);

      mesh_from[31]= 0;

      if (strcmp(mesh_from,esp_board_uuid)==0) {

        data.data = tx_buf;

        data.size = sizeof(tx_buf);

        data.proto = MESH_PROTO_BIN;

        is_running = true;

        mesh_initialized= 1;

        memcpy(send_data,&esp32_mesh_ROBOR2_ConstB.StringtoASCII3[0],31);

        send_data[31]= 0;

        memcpy(tx_buf, (uint8_t *)send_data, strlen(send_data));

        tx_buf[strlen(send_data)]= 0;

        mesh_to[0]= 0;

        memcpy(mesh_to,&esp32_mesh_ROBOR2_ConstB.StringtoASCII1[0],31);

        mesh_to[31]= 0;

        if (strcmp(mesh_to,root_address)==0) {

          err = esp_mesh_send(NULL, &data, MESH_DATA_P2P, NULL, 0);

          ESP_LOGI(MESH_TAG, "Sent data to root");

        } else {

          set_MAC(&mac_add, mesh_to);

          err = esp_mesh_send(&mac_add, &data, MESH_DATA_P2P, NULL, 0);

          ESP_LOGI(MESH_TAG, "Sent data to "MACSTR" ", MAC2STR(mac_add.addr));

        }

        vTaskDelay(100 / portTICK_RATE_MS);

        mesh_to[0]= 0;

        memcpy(mesh_to,&esp32_mesh_ROBOR2_ConstB.StringtoASCII2[0],31);

        mesh_to[31]= 0;

        if (strcmp(mesh_to,root_address)==0) {

          err = esp_mesh_send(NULL, &data, MESH_DATA_P2P, NULL, 0);

          ESP_LOGI(MESH_TAG, "Sent data to root");

        } else {

          set_MAC(&mac_add, mesh_to);

          err = esp_mesh_send(&mac_add, &data, MESH_DATA_P2P, NULL, 0);

          ESP_LOGI(MESH_TAG, "Sent data to "MACSTR" ", MAC2STR(mac_add.addr));

        }

        vTaskDelay(100 / portTICK_RATE_MS);

      }

      //memcpy(sql_buffer,

      //jsonbuffer[0]='\0';

      //db_start

      //jsonbuffer[strlen(jsonbuffer)-1]= '\0';

      //memcpy(

    }

  }

}

/* Model terminate function */

void esp32_mesh_ROBOR2_terminate(void)

{

  /* (no terminate code required) */

}

/* [EOF] */