kbf/src/gpio.cpp

#include "kbf/gpio.h"

#include <esp_log.h>
#include <esp_sleep.h>

#include "kbf.h"
#include "kbf/macros.h"

using namespace kbf;
using namespace kbf::rtos;
using std::string;

gpio::Output::Output(int pin) : pin(static_cast<gpio_num_t>(pin)) {
    ESP_LOGI(TAG, "setting GPIO %d to OUTPUT mode", pin);
    CHECK(gpio_reset_pin(this->pin));
    CHECK(gpio_set_direction(this->pin, GPIO_MODE_OUTPUT));
}

void gpio::Output::high() const {
    gpio_set_level(pin, 1);
}

void gpio::Output::low() const {
    gpio_set_level(pin, 0);
}

void gpio::Output::startPulse(int delay_ms, int limit) {
    ESP_LOGI(TAG, "starting pulse on GPIO %d; delay = %d, limit = %d", pin, delay_ms, limit);
    string taskName = "kbf_gpio_p" + std::to_string(pin);
    if (pulseTask != nullptr && pulseTask->isRunning()) {
        ESP_LOGE(TAG, "pulse task already running");
        ABORT("fix me");
    }
    pulseDelay = delay_ms;
    pulseLimit = limit;
    delete pulseTask;
    pulseTask = new Task(taskName, pulseCallback, this);
}

void gpio::Output::stopPulse() {
    ESP_LOGI(TAG, "stopping pulse on GPIO %d", pin);
    if (pulseTask == nullptr) {
        ESP_LOGE(TAG, "pulse task not running");
        ABORT("fix me");
    }
    pulseTask->stop();
    low();
}

void gpio::Output::pulseCallback(void *arg_ptr) {
    auto output = static_cast<Output *>(arg_ptr);
    int count = 0;
    while (output->pulseLimit < 0 || count++ < output->pulseLimit) {
        output->high();
        kbf::sleep(output->pulseDelay);
        output->low();
        kbf::sleep(output->pulseDelay);
    }
}

gpio::Input::Input(int pin, void *userData) : pin(static_cast<gpio_num_t>(pin)), userData(userData) {
    ESP_LOGI(TAG, "setting GPIO %d to INPUT mode", pin);

    static bool isrInstalled = false;
    if (!isrInstalled) {
        ESP_LOGI(TAG, "installing ISR service");
        CHECK(gpio_install_isr_service(0));
        isrInstalled = true;
    }

    CHECK(gpio_reset_pin(this->pin));
    CHECK(gpio_set_direction(this->pin, GPIO_MODE_INPUT));
    CHECK(gpio_set_intr_type(this->pin, GPIO_INTR_ANYEDGE));
    CHECK(gpio_isr_handler_add(this->pin, interruptHandler, this));
}

void gpio::Input::interruptHandler(void *data) {
    auto input = static_cast<Input *>(data);
    if (input->isHigh() && input->onHigh) {
        input->onHigh(*input);
    } else if (input->isLow() && input->onLow) {
        input->onLow(*input);
    }
}

bool gpio::Input::isHigh() const {
    return gpio_get_level(pin) == 1;
}

bool gpio::Input::isLow() const {
    return gpio_get_level(pin) == 0;
}

gpio::Input::~Input() {
    CHECK_ABORT(gpio_isr_handler_remove(pin));
}