572 lines
18 KiB
C++
572 lines
18 KiB
C++
#include <esp32-hal.h>
|
|
#include "Gpio.h"
|
|
#include "Config.h"
|
|
#include "Arduino.h"
|
|
#include "Logger.h"
|
|
#include "PreferencesKeys.h"
|
|
#include "RestartReason.h"
|
|
#include "networkDevices/LAN8720Definitions.h"
|
|
#include "networkDevices/DM9051Definitions.h"
|
|
#include "networkDevices/W5500Definitions.h"
|
|
|
|
Gpio* Gpio::_inst = nullptr;
|
|
|
|
Gpio::Gpio(Preferences* preferences)
|
|
: _preferences(preferences)
|
|
{
|
|
_inst = this;
|
|
loadPinConfiguration();
|
|
_inst->init();
|
|
}
|
|
|
|
|
|
bool Gpio::isTriggered(const PinEntry& entry)
|
|
{
|
|
// Log->println(" ------------ ");
|
|
|
|
const int threshold = 3;
|
|
|
|
uint8_t state = digitalRead(entry.pin);
|
|
uint8_t lastState = (_triggerState[entry.pin] & 0x80) >> 7;
|
|
|
|
uint8_t pinState = _triggerState[entry.pin] & 0x7f;
|
|
pinState = pinState << 1 | state;
|
|
_triggerState[entry.pin] = (pinState & 0x7f) | lastState << 7;
|
|
// Log->print("Trigger state: ");
|
|
// Log->println(_triggerState[entry.pin], 2);
|
|
|
|
pinState = pinState & 0x07;
|
|
// Log->print("Val: ");
|
|
// Log->println(pinState);
|
|
|
|
|
|
if(pinState != 0x00 && pinState != 0x07)
|
|
{
|
|
return false;
|
|
}
|
|
// Log->print("Last State: ");
|
|
// Log->println(lastState);
|
|
// Log->print("State: ");
|
|
// Log->println(state);
|
|
|
|
if(state != lastState)
|
|
{
|
|
// Log->print("State changed: ");
|
|
// Log->println(state);
|
|
_triggerState[entry.pin] = (pinState & 0x7f) | state << 7;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(entry.role == PinRole::GeneralInputPullDown || entry.role == PinRole::GeneralInputPullUp)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return state == LOW;
|
|
}
|
|
|
|
void Gpio::onTimer()
|
|
{
|
|
for(const auto& entry : _inst->_pinConfiguration)
|
|
{
|
|
switch(entry.role)
|
|
{
|
|
case PinRole::InputLock:
|
|
case PinRole::InputUnlock:
|
|
case PinRole::InputUnlatch:
|
|
case PinRole::InputLockNgo:
|
|
case PinRole::InputLockNgoUnlatch:
|
|
case PinRole::InputElectricStrikeActuation:
|
|
case PinRole::InputActivateRTO:
|
|
case PinRole::InputActivateCM:
|
|
case PinRole::InputDeactivateRtoCm:
|
|
case PinRole::InputDeactivateRTO:
|
|
case PinRole::InputDeactivateCM:
|
|
case PinRole::GeneralInputPullDown:
|
|
case PinRole::GeneralInputPullUp:
|
|
if(isTriggered(entry))
|
|
{
|
|
_inst->notify(getGpioAction(entry.role), entry.pin);
|
|
}
|
|
break;
|
|
case PinRole::OutputHighLocked:
|
|
case PinRole::OutputHighUnlocked:
|
|
case PinRole::OutputHighMotorBlocked:
|
|
case PinRole::OutputHighRtoActive:
|
|
case PinRole::OutputHighCmActive:
|
|
case PinRole::OutputHighRtoOrCmActive:
|
|
case PinRole::GeneralOutput:
|
|
case PinRole::Ethernet:
|
|
// ignore. This case should not occur since pins are configured as output
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Gpio::isrOnTimer()
|
|
{
|
|
_inst->onTimer();
|
|
}
|
|
|
|
void Gpio::init()
|
|
{
|
|
_inst->_triggerState.reserve(_inst->availablePins().size());
|
|
for(int i=0; i<_inst->availablePins().size(); i++)
|
|
{
|
|
_inst->_triggerState.push_back(0);
|
|
}
|
|
|
|
bool hasInputPin = false;
|
|
|
|
if (_inst->_preferences->getBool(preference_cred_bypass_boot_btn_enabled, false))
|
|
{
|
|
pinMode(BOOT_BUTTON_GPIO, INPUT);
|
|
}
|
|
if (_inst->_preferences->getInt(preference_cred_bypass_gpio_high, -1) > -1)
|
|
{
|
|
pinMode(_inst->_preferences->getInt(preference_cred_bypass_gpio_high, -1), INPUT);
|
|
}
|
|
if (_inst->_preferences->getInt(preference_cred_bypass_gpio_low, -1) > -1)
|
|
{
|
|
pinMode(_inst->_preferences->getInt(preference_cred_bypass_gpio_low, -1), INPUT);
|
|
}
|
|
|
|
for(const auto& entry : _inst->_pinConfiguration)
|
|
{
|
|
const auto it = std::find(_inst->availablePins().begin(), _inst->availablePins().end(), entry.pin);
|
|
|
|
if(it == _inst->availablePins().end())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
switch(entry.role)
|
|
{
|
|
case PinRole::InputLock:
|
|
case PinRole::InputUnlock:
|
|
case PinRole::InputUnlatch:
|
|
case PinRole::InputLockNgo:
|
|
case PinRole::InputLockNgoUnlatch:
|
|
case PinRole::InputElectricStrikeActuation:
|
|
case PinRole::InputActivateRTO:
|
|
case PinRole::InputActivateCM:
|
|
case PinRole::InputDeactivateRtoCm:
|
|
case PinRole::InputDeactivateRTO:
|
|
case PinRole::InputDeactivateCM:
|
|
case PinRole::GeneralInputPullUp:
|
|
pinMode(entry.pin, INPUT_PULLUP);
|
|
hasInputPin = true;
|
|
break;
|
|
case PinRole::GeneralInputPullDown:
|
|
pinMode(entry.pin, INPUT_PULLDOWN);
|
|
hasInputPin = true;
|
|
break;
|
|
case PinRole::OutputHighLocked:
|
|
case PinRole::OutputHighUnlocked:
|
|
case PinRole::OutputHighMotorBlocked:
|
|
case PinRole::OutputHighRtoActive:
|
|
case PinRole::OutputHighCmActive:
|
|
case PinRole::OutputHighRtoOrCmActive:
|
|
case PinRole::GeneralOutput:
|
|
pinMode(entry.pin, OUTPUT);
|
|
break;
|
|
case PinRole::Ethernet:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(hasInputPin)
|
|
{
|
|
_inst->timer = timerBegin(1000000);
|
|
timerAttachInterrupt(_inst->timer, isrOnTimer);
|
|
timerAlarm(_inst->timer, 100000, true, 0);
|
|
}
|
|
}
|
|
|
|
const std::vector<uint8_t>& Gpio::availablePins() const
|
|
{
|
|
return _availablePins;
|
|
}
|
|
|
|
void Gpio::loadPinConfiguration()
|
|
{
|
|
Log->println("Load GPIO configuration");
|
|
size_t storedLength = _preferences->getBytesLength(preference_gpio_configuration);
|
|
if(storedLength == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
uint8_t serialized[storedLength];
|
|
memset(serialized, 0, sizeof(serialized));
|
|
|
|
size_t size = _preferences->getBytes(preference_gpio_configuration, serialized, sizeof(serialized));
|
|
|
|
if(size == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
size_t numEntries = size / 2;
|
|
|
|
_pinConfiguration.clear();
|
|
_pinConfiguration.reserve(numEntries);
|
|
|
|
std::vector<int> disabledPins = getDisabledPins();
|
|
|
|
for(int i=0; i < numEntries; i++)
|
|
{
|
|
PinEntry entry;
|
|
entry.pin = serialized[i * 2];
|
|
Log->print(("Pin "));
|
|
Log->println(entry.pin);
|
|
|
|
if(std::find(disabledPins.begin(), disabledPins.end(), entry.pin) == disabledPins.end())
|
|
{
|
|
if(entry.role == PinRole::Ethernet)
|
|
{
|
|
entry.role = PinRole::Disabled;
|
|
}
|
|
entry.role = (PinRole) serialized[(i * 2 + 1)];
|
|
Log->println("Not found in Ethernet disabled pins");
|
|
Log->print(("Role: "));
|
|
Log->println(getRoleDescription(entry.role));
|
|
}
|
|
else
|
|
{
|
|
entry.role = PinRole::Ethernet;
|
|
Log->println("Found in Ethernet disabled pins");
|
|
Log->print(("Role: "));
|
|
Log->println(getRoleDescription(entry.role));
|
|
}
|
|
if(entry.role != PinRole::Disabled)
|
|
{
|
|
_pinConfiguration.push_back(entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
const std::vector<int> Gpio::getDisabledPins() const
|
|
{
|
|
std::vector<int> disabledPins;
|
|
|
|
if (_preferences->getBool(preference_cred_bypass_boot_btn_enabled, false))
|
|
{
|
|
disabledPins.push_back(BOOT_BUTTON_GPIO);
|
|
}
|
|
if (_preferences->getInt(preference_cred_bypass_gpio_high, -1) > -1)
|
|
{
|
|
disabledPins.push_back(_preferences->getInt(preference_cred_bypass_gpio_high, -1));
|
|
}
|
|
if (_preferences->getInt(preference_cred_bypass_gpio_low, -1) > -1)
|
|
{
|
|
disabledPins.push_back(_preferences->getInt(preference_cred_bypass_gpio_low, -1));
|
|
}
|
|
|
|
switch(_preferences->getInt(preference_network_hardware, 0))
|
|
{
|
|
case 2:
|
|
disabledPins.push_back(ETH_PHY_CS_GENERIC_W5500);
|
|
disabledPins.push_back(ETH_PHY_IRQ_GENERIC_W5500);
|
|
disabledPins.push_back(ETH_PHY_RST_GENERIC_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_SCK_GENERIC_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_MISO_GENERIC_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_MOSI_GENERIC_W5500);
|
|
break;
|
|
case 3:
|
|
disabledPins.push_back(ETH_PHY_CS_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_IRQ_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_RST_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_SCK_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_MISO_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_MOSI_M5_W5500);
|
|
break;
|
|
case 10:
|
|
disabledPins.push_back(ETH_PHY_CS_M5_W5500_S3);
|
|
disabledPins.push_back(ETH_PHY_IRQ_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_RST_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_SCK_M5_W5500_S3);
|
|
disabledPins.push_back(ETH_PHY_SPI_MISO_M5_W5500_S3);
|
|
disabledPins.push_back(ETH_PHY_SPI_MOSI_M5_W5500_S3);
|
|
break;
|
|
case 9:
|
|
disabledPins.push_back(ETH_PHY_CS_ETH01EVO);
|
|
disabledPins.push_back(ETH_PHY_IRQ_ETH01EVO);
|
|
disabledPins.push_back(ETH_PHY_RST_ETH01EVO);
|
|
disabledPins.push_back(ETH_PHY_SPI_SCK_ETH01EVO);
|
|
disabledPins.push_back(ETH_PHY_SPI_MISO_ETH01EVO);
|
|
disabledPins.push_back(ETH_PHY_SPI_MOSI_ETH01EVO);
|
|
break;
|
|
case 6:
|
|
disabledPins.push_back(ETH_PHY_CS_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_IRQ_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_RST_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_SCK_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_MISO_M5_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_MOSI_M5_W5500);
|
|
break;
|
|
case 12:
|
|
disabledPins.push_back(ETH_PHY_CS_ELITE_W5500);
|
|
disabledPins.push_back(ETH_PHY_IRQ_ELITE_W5500);
|
|
disabledPins.push_back(ETH_PHY_RST_ELITE_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_SCK_ELITE_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_MISO_ELITE_W5500);
|
|
disabledPins.push_back(ETH_PHY_SPI_MOSI_ELITE_W5500);
|
|
break;
|
|
case 11:
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_cs, -1));
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_irq, -1));
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_rst, -1));
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_sck, -1));
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_miso, -1));
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_mosi, -1));
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_pwr, -1));
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_mdc, -1));
|
|
disabledPins.push_back(_preferences->getInt(preference_network_custom_mdio, -1));
|
|
break;
|
|
#if defined(CONFIG_IDF_TARGET_ESP32)
|
|
case 4:
|
|
disabledPins.push_back(12);
|
|
disabledPins.push_back(ETH_RESET_PIN_LAN8720);
|
|
disabledPins.push_back(ETH_PHY_MDC_LAN8720);
|
|
disabledPins.push_back(ETH_PHY_MDIO_LAN8720);
|
|
break;
|
|
case 5:
|
|
disabledPins.push_back(16);
|
|
disabledPins.push_back(ETH_RESET_PIN_LAN8720);
|
|
disabledPins.push_back(ETH_PHY_MDC_LAN8720);
|
|
disabledPins.push_back(ETH_PHY_MDIO_LAN8720);
|
|
break;
|
|
case 8:
|
|
disabledPins.push_back(5);
|
|
disabledPins.push_back(ETH_RESET_PIN_LAN8720);
|
|
disabledPins.push_back(ETH_PHY_MDC_LAN8720);
|
|
disabledPins.push_back(ETH_PHY_MDIO_LAN8720);
|
|
break;
|
|
case 7:
|
|
disabledPins.push_back(-1);
|
|
disabledPins.push_back(ETH_RESET_PIN_LAN8720);
|
|
disabledPins.push_back(ETH_PHY_MDC_LAN8720);
|
|
disabledPins.push_back(ETH_PHY_MDIO_LAN8720);
|
|
break;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
|
|
Log->print(("GPIO Boot button and Ethernet disabled pins:"));
|
|
for_each_n(disabledPins.begin(), disabledPins.size(),
|
|
[](int x)
|
|
{
|
|
Log->print(" ");
|
|
Log->print(x);
|
|
});
|
|
Log->println();
|
|
return disabledPins;
|
|
}
|
|
|
|
void Gpio::savePinConfiguration(const std::vector<PinEntry> &pinConfiguration)
|
|
{
|
|
Log->println("Save GPIO configuration");
|
|
int8_t serialized[std::max(pinConfiguration.size() * 2, _preferences->getBytesLength(preference_gpio_configuration))];
|
|
memset(serialized, 0, sizeof(serialized));
|
|
|
|
std::vector<int> disabledPins = getDisabledPins();
|
|
|
|
int len = pinConfiguration.size();
|
|
for(int i=0; i < len; i++)
|
|
{
|
|
const auto& entry = pinConfiguration[i];
|
|
Log->print(("Pin "));
|
|
Log->println(entry.pin);
|
|
|
|
if(std::find(disabledPins.begin(), disabledPins.end(), entry.pin) != disabledPins.end())
|
|
{
|
|
serialized[i * 2] = entry.pin;
|
|
serialized[i * 2 + 1] = (int8_t)PinRole::Ethernet;
|
|
Log->println("Found in Ethernet disabled pins");
|
|
Log->print(("Role: "));
|
|
Log->println(getRoleDescription(PinRole::Ethernet));
|
|
|
|
}
|
|
else
|
|
{
|
|
if(entry.role != PinRole::Disabled && entry.role != PinRole::Ethernet)
|
|
{
|
|
serialized[i * 2] = entry.pin;
|
|
serialized[i * 2 + 1] = (int8_t) entry.role;
|
|
Log->println("Not found in Ethernet disabled pins");
|
|
Log->print(("Role: "));
|
|
Log->println(getRoleDescription(entry.role));
|
|
}
|
|
}
|
|
}
|
|
|
|
_preferences->putBytes(preference_gpio_configuration, serialized, sizeof(serialized));
|
|
}
|
|
|
|
const std::vector<PinEntry> &Gpio::pinConfiguration() const
|
|
{
|
|
return _pinConfiguration;
|
|
}
|
|
|
|
const PinRole Gpio::getPinRole(const int &pin) const
|
|
{
|
|
for(const auto& pinEntry : _pinConfiguration)
|
|
{
|
|
if(pinEntry.pin == pin)
|
|
{
|
|
return pinEntry.role;
|
|
}
|
|
}
|
|
return PinRole::Disabled;
|
|
}
|
|
|
|
String Gpio::getRoleDescription(const PinRole& role) const
|
|
{
|
|
switch(role)
|
|
{
|
|
case PinRole::Disabled:
|
|
return "Disabled";
|
|
case PinRole::InputLock:
|
|
return "Input: Lock";
|
|
case PinRole::InputUnlock:
|
|
return "Input: Unlock";
|
|
case PinRole::InputUnlatch:
|
|
return "Input: Unlatch";
|
|
case PinRole::InputLockNgo:
|
|
return "Input: Lock n Go";
|
|
case PinRole::InputLockNgoUnlatch:
|
|
return "Input: Lock n Go and unlatch";
|
|
case PinRole::InputElectricStrikeActuation:
|
|
return "Input: Electric strike actuation";
|
|
case PinRole::InputActivateRTO:
|
|
return "Input: Activate RTO";
|
|
case PinRole::InputActivateCM:
|
|
return "Input: Activate CM";
|
|
case PinRole::InputDeactivateRtoCm:
|
|
return "Input: Deactivate RTO/CM";
|
|
case PinRole::InputDeactivateRTO:
|
|
return "Input: Deactivate RTO";
|
|
case PinRole::InputDeactivateCM:
|
|
return "Input: Deactivate CM";
|
|
case PinRole::OutputHighLocked:
|
|
return "Output: High when locked";
|
|
case PinRole::OutputHighUnlocked:
|
|
return "Output: High when unlocked";
|
|
case PinRole::OutputHighMotorBlocked:
|
|
return "Output: High when motor blocked";
|
|
case PinRole::OutputHighRtoActive:
|
|
return "Output: High when RTO active";
|
|
case PinRole::OutputHighCmActive:
|
|
return "Output: High when CM active";
|
|
case PinRole::OutputHighRtoOrCmActive:
|
|
return "Output: High when RTO or CM active";
|
|
case PinRole::GeneralOutput:
|
|
return "General output";
|
|
case PinRole::GeneralInputPullDown:
|
|
return "General input (Pull-down)";
|
|
case PinRole::GeneralInputPullUp:
|
|
return "General input (Pull-up)";
|
|
case PinRole::Ethernet:
|
|
return "Ethernet";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
|
|
GpioAction Gpio::getGpioAction(const PinRole &role) const
|
|
{
|
|
switch(role)
|
|
{
|
|
case PinRole::Disabled:
|
|
return GpioAction::None;
|
|
case PinRole::InputLock:
|
|
return GpioAction::Lock;
|
|
case PinRole::InputUnlock:
|
|
return GpioAction::Unlock;
|
|
case PinRole::InputUnlatch:
|
|
return GpioAction::Unlatch;
|
|
case PinRole::InputLockNgo:
|
|
return GpioAction::LockNgo;
|
|
case PinRole::InputLockNgoUnlatch:
|
|
return GpioAction::LockNgoUnlatch;
|
|
case PinRole::InputElectricStrikeActuation:
|
|
return GpioAction::ElectricStrikeActuation;
|
|
case PinRole::InputActivateRTO:
|
|
return GpioAction::ActivateRTO;
|
|
case PinRole::InputActivateCM:
|
|
return GpioAction::ActivateCM;
|
|
case PinRole::InputDeactivateRtoCm:
|
|
return GpioAction::DeactivateRtoCm;
|
|
case PinRole::InputDeactivateRTO:
|
|
return GpioAction::DeactivateRTO;
|
|
case PinRole::InputDeactivateCM:
|
|
return GpioAction::DeactivateCM;
|
|
|
|
case PinRole::GeneralInputPullDown:
|
|
case PinRole::GeneralInputPullUp:
|
|
return GpioAction::GeneralInput;
|
|
|
|
case PinRole::GeneralOutput:
|
|
case PinRole::Ethernet:
|
|
case PinRole::OutputHighLocked:
|
|
case PinRole::OutputHighUnlocked:
|
|
case PinRole::OutputHighMotorBlocked:
|
|
case PinRole::OutputHighRtoActive:
|
|
case PinRole::OutputHighCmActive:
|
|
case PinRole::OutputHighRtoOrCmActive:
|
|
default:
|
|
return GpioAction::None;
|
|
}
|
|
}
|
|
|
|
|
|
void Gpio::getConfigurationText(String& text, const std::vector<PinEntry>& pinConfiguration, const String& linebreak) const
|
|
{
|
|
for(const auto& entry : pinConfiguration)
|
|
{
|
|
if(entry.role != PinRole::Disabled)
|
|
{
|
|
text.concat("GPIO ");
|
|
text.concat(entry.pin);
|
|
if(entry.pin < 10)
|
|
{
|
|
text.concat(' ');
|
|
}
|
|
text.concat(": ");
|
|
text.concat(getRoleDescription(entry.role));
|
|
text.concat(linebreak);
|
|
}
|
|
}
|
|
}
|
|
|
|
const std::vector<PinRole>& Gpio::getAllRoles() const
|
|
{
|
|
return _allRoles;
|
|
}
|
|
|
|
void Gpio::notify(const GpioAction &action, const int& pin)
|
|
{
|
|
for(auto& callback : _callbacks)
|
|
{
|
|
callback(action, pin);
|
|
}
|
|
}
|
|
|
|
void Gpio::addCallback(std::function<void(const GpioAction&, const int&)> callback)
|
|
{
|
|
_callbacks.push_back(callback);
|
|
}
|
|
|
|
void Gpio::setPinOutput(const uint8_t& pin, const uint8_t& state)
|
|
{
|
|
digitalWrite(pin, state);
|
|
}
|