ApfelNetzwerk/embedded/main/apple.c

#include "nvs_flash.h"
#include "esp_netif.h"
#include "zh_network.h"
#include "driver/gpio.h"
#include "lwip/sockets.h"
#include <strings.h>

#define EXIT_NODE a

#ifdef EXIT_NODE
#define TAG "TCP"
#define PORT 7999
#define HOST_IP_ADDR
#define ESP_WIFI_SSID
#define ESP_WIFI_PASS
#endif

#define ESP_CHANNEL 7

#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]

void zh_network_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data);

uint8_t broadcast[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t test[6] = {0x09, 0xF2, 0x69, 0x42, 0x11, 0xA9};

typedef struct
{
    float temperature;
    float battery_voltage;
    unsigned long up_time;
} sensor_message_t;

typedef struct
{
    uint8_t mac[6];
    float temperature;
    float battery_voltage;
    unsigned long up_time;
} tcp_message_t;

int sock;

void app_main(void)
{
    esp_log_level_set("zh_vector", ESP_LOG_NONE);
    esp_log_level_set("zh_network", ESP_LOG_NONE);
    nvs_flash_init();
    esp_netif_init();
    esp_event_loop_create_default();
    wifi_init_config_t wifi_init_config = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&wifi_init_config);
    esp_wifi_set_mode(WIFI_MODE_STA);

#ifdef EXIT_NODE
    wifi_config_t wifi_config = {
        .sta = {
            .ssid = ESP_WIFI_SSID,
            .password = ESP_WIFI_PASS,
            .channel = ESP_CHANNEL},

    };
    esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config);

    esp_wifi_start();
    esp_wifi_set_channel(ESP_CHANNEL, 1);
    esp_wifi_connect();
#endif
    // esp_wifi_set_max_tx_power(8); // Power reduction is for example and testing purposes only. Do not use in your own programs!
    zh_network_init_config_t network_init_config = ZH_NETWORK_INIT_CONFIG_DEFAULT();
    network_init_config.max_waiting_time = 1000;
    network_init_config.wifi_channel = ESP_CHANNEL;
    zh_network_init(&network_init_config);
#ifdef CONFIG_IDF_TARGET_ESP8266
    esp_event_handler_register(ZH_NETWORK, ESP_EVENT_ANY_ID, &zh_network_event_handler, NULL);
#else
    esp_event_handler_instance_register(ZH_NETWORK, ESP_EVENT_ANY_ID, &zh_network_event_handler, NULL, NULL);
#endif

#ifdef EXIT_NODE
    uint8_t data = 0xFF;

    for (;;)
    {
        struct sockaddr_in destAddr;
        bzero(&destAddr, sizeof(destAddr));
        destAddr.sin_family = AF_INET;
        destAddr.sin_port = htons(7999);
        inet_pton(AF_INET, HOST_IP_ADDR, &destAddr.sin_addr);

        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sock < 0)
        {
            ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
            return;
        }
        ESP_LOGI(TAG, "Socket created");
        int err = connect(sock, (struct sockaddr *)&destAddr, sizeof(destAddr));
        if (err != 0)
        {
            ESP_LOGE(TAG, "Socket unable to connect: errno %d", errno);
            close(sock);
            vTaskDelay(500 / portTICK_PERIOD_MS);
            continue;
        }
        ESP_LOGI(TAG, "Successfully connected");
        for (;;)
        {
            tcp_message_t packet;
            memcpy(packet.mac, test, 6);
            packet.battery_voltage = 3.3f;
            packet.temperature = 21.2f;
            packet.up_time = 213273948;
            vTaskDelay(10000 / portTICK_PERIOD_MS);
            zh_network_send(broadcast, (uint8_t *)&data, sizeof(data));
            int err = send(sock, (uint8_t *)&packet, sizeof(tcp_message_t), 0);
            if (err < 0)
            {
                ESP_LOGE(TAG, "Error ocured during sending: errno %d", errno);
                break;
            }
        }
        close(sock);
    }
#endif
}

void zh_network_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
{
    switch (event_id)
    {
    case ZH_NETWORK_ON_RECV_EVENT:;
        zh_network_event_on_recv_t *recv_data = event_data;
#ifdef EXIT_NODE
        sensor_message_t *recv_message = (sensor_message_t *)recv_data->data;
        tcp_message_t packet;
        memcpy(packet.mac, recv_data->mac_addr, 6);
        packet.temperature = recv_message->temperature;
        packet.battery_voltage = recv_message->battery_voltage;
        packet.up_time = recv_message->up_time;
        heap_caps_free(recv_data->data);
        int err = send(sock, (uint8_t *)&packet, sizeof(packet), 0);
        if (err < 0)
        {
            ESP_LOGE(TAG, "Error sending TCP data");
            break;
        }
#else
        heap_caps_free(recv_data->data);
    // READ DATA
    zh_network_send(recv_data->mac_addr, )
#endif
    case ZH_NETWORK_ON_SEND_EVENT:;
        zh_network_event_on_send_t *send_data = event_data;
        if (send_data->status == ZH_NETWORK_SEND_SUCCESS)
        {
            printf("Message to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.\n", MAC2STR(send_data->mac_addr));
        }
        else
        {
            printf("Message to MAC %02X:%02X:%02X:%02X:%02X:%02X sent fail.\n", MAC2STR(send_data->mac_addr));
        }
        break;
    default:
        break;
    }
}