abfall/src/utils.cpp

#include "utils.h"

#include <algorithm>
#include <iostream>
#include <sstream>

using namespace std;

bool isDST(int8_t day, int8_t month, int8_t dow) {
    // January, february, november and december are out.
    if (month < 3 || month > 10) {
        return false;
    }

    // April to September are in
    if (month > 3 && month < 10) {
        return true;
    }

    int previousSunday = day - dow;

    // In march, we are DST if our previous sunday was on or after the 25th.
    if (month == 3) {
        return previousSunday >= 25;
    }

    // In October we must be before the last sunday to be DST.
    // That means the previous sunday must be before the 25st.
    return previousSunday < 25;
}

chrono::year_month_day stringToDate(const std::string &dateStr) {
    istringstream partss(dateStr);
    string day_str, month_str, year_str;
    getline(partss, day_str, '.');
    getline(partss, month_str, '.');
    getline(partss, year_str, '.');
    int day = atoi(day_str.c_str());
    int month = atoi(month_str.c_str());
    int year = atoi(year_str.c_str());
    chrono::year_month_day date{chrono::year{year}, chrono::month{(uint)month},
                                chrono::day{(uint)day}};
    return date;
}

std::vector<std::string> split(const std::string &s, const std::string &delimiter) {
    std::vector<std::string> result;
    std::string::size_type start{0};
    std::string::size_type pos{0};
    do {
        pos = s.find_first_of(delimiter, start);
        result.push_back(s.substr(start, pos - start));
        start = pos + 1;
    } while (pos != std::string::npos);
    return result;
}

std::vector<WasteDate> parseCsv(const std::string &csv) {
    istringstream stream(csv);
    string line{""};
    vector<WasteDate> wasteDates;

    // Get rid of the first line (header)
    getline(stream, line);

    while (getline(stream, line)) {
        auto tokenVec = split(line, ";");

        for (unsigned i = 0; i < tokenVec.size(); i++) {
            string token = tokenVec.at(i);

            if (token.length() == 0)
                continue;

            auto date = stringToDate(token);

            // Take existing date or create a new one.
            std::vector<WasteDate>::iterator it;
            it = std::find_if(wasteDates.begin(), wasteDates.end(),
                              [&date](const WasteDate &x) { return date == x.date; });
            if (it == wasteDates.end()) {
                WasteDate wd;
                wd.date = date;
                wasteDates.push_back(wd);
                it = std::prev(wasteDates.end());
            }

            switch (i) {
            case 0:
                it->wasteTypes.push_back(Waste::GelberSack);
                break;
            case 1:
                it->wasteTypes.push_back(Waste::Papiertonne);
                break;
            case 2:
                it->wasteTypes.push_back(Waste::Biotonne);
                break;
            case 3:
                it->wasteTypes.push_back(Waste::Restmuell);
                break;
            case 4:
                it->wasteTypes.push_back(Waste::Problemstoffmobil);
                break;
            default:
#ifdef DEBUG
                printf("Unknown waste token detected.\n");
#endif
                break;
            }
        }
    }

    return wasteDates;
}

int wifi_setup(uint32_t country, const string &ssid, const string &pw, bool firstTry) {
    if (firstTry) {
        if (cyw43_arch_init_with_country(country)) {
            return 1;
        }
    }

    cyw43_arch_enable_sta_mode();

    netif_set_hostname(netif_default, "AbfallPicoW");

    if (cyw43_arch_wifi_connect_async(ssid.c_str(), pw.c_str(), CYW43_AUTH_WPA2_MIXED_PSK)) {
        return 2;
    }

    int flashrate = 1000;
    int status = CYW43_LINK_UP + 1;

    while (status >= 0 && status != CYW43_LINK_UP) {
        int status_new = cyw43_tcpip_link_status(&cyw43_state, CYW43_ITF_STA);

        if (status_new != status) {
            status = status_new;
            if (status < 0) {
                continue;
            }
            flashrate = flashrate / (status + 1);
        }
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
        sleep_ms(flashrate);
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
        sleep_ms(flashrate);
    }

    if (status < 0) {
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
    } else {
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
#ifdef DEBUG
        printf("IP: %s\n", ip4addr_ntoa(netif_ip_addr4(netif_default)));
#endif
    }

    return status;
}

void wifi_enable() {
    const string ssid{"Apis cerana"};
    const string pw{"2JkJEh2vptVT"};
    const uint32_t country{CYW43_COUNTRY_GERMANY};

    bool firstTry = true;
    int res = -1;
    do {
        if (firstTry) {
            res = wifi_setup(country, ssid, pw, true);
            firstTry = false;
        } else {
#ifdef DEBUG
            printf("Setting up connection failed. Trying again after 5 sec...\n");
#endif
            sleep_ms(5000);
            res = wifi_setup(country, ssid, pw, false);
        }

    } while (res != CYW43_LINK_UP);
}

void wifi_disable() {

    cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
    cyw43_wifi_leave(&cyw43_state, CYW43_ITF_STA);
}