/**
* MechBase PLC — Ladder Logic Interpreter v2 Implementation
*
* IEC 61131-3 ladder logic interpreter for ESP32.
*
* Contact instructions: NO, NC, Rising Edge, Falling Edge, Timer bits (EN/TT/DN)
* Output instructions: OTE, OTL, OTU, TON, TOF, TP
* Network structure: Parallel branching, series/parallel evaluation
*/
#include "ladder_interpreter.h"
// ─────────────────────────────────────────────────────────────────────────────
// Branch evaluation
// ─────────────────────────────────────────────────────────────────────────────
bool Branch::evaluate(LadderInterpreter* interp, bool is_output) {
power_flow = true;
for (auto& elem : elements) {
bool result = false;
if (is_output) {
// ── Output instructions ──────────────────────────────────────
switch (static_cast<OutputType>(elem.type)) {
case OT_OTE: {
// Output Energize — follows input power
power_flow = false; // OTE is terminal, no more flow
interp->writeBool(elem.tag, true);
return true;
}
case OT_OTL: {
// Output Latch (SET) — stays ON once set
power_flow = false;
if (this->power_flow) {
interp->writeBool(elem.tag, true);
}
return true;
}
case OT_OTU: {
// Output Unlatch (RESET) — clears latched output
power_flow = false;
if (this->power_flow) {
interp->writeBool(elem.tag, false);
}
return true;
}
default:
break;
}
}
else {
// ── Contact instructions ─────────────────────────────────────
switch (static_cast<ContactType>(elem.type)) {
case CT_NO: {
// Normally Open — passes when TRUE
result = interp->readBool(elem.tag);
break;
}
case CT_NC: {
// Normally Closed — passes when FALSE
result = !interp->readBool(elem.tag);
break;
}
case CT_RISING: {
// Rising Edge — single scan TRUE→FALSE
bool current = interp->readBool(elem.tag);
result = (current && !elem.last_state);
elem.last_state = current;
break;
}
case CT_FALLING: {
// Falling Edge — single scan FALSE→TRUE
bool current = interp->readBool(elem.tag);
result = (!current && elem.last_state);
elem.last_state = current;
break;
}
case CT_TON_DN:
case CT_TON_TT:
case CT_TON_EN: {
// TON status bits
uint8_t tidx = interp->parseTimerIndex(elem.tag);
LadderTimer& t = interp->getTimer(tidx);
switch (elem.type) {
case CT_TON_DN: result = t.dn; break;
case CT_TON_TT: result = t.tt; break;
case CT_TON_EN: result = t.en; break;
default: result = false;
}
break;
}
case CT_TOF_DN:
case CT_TOF_TT:
case CT_TOF_EN: {
// TOF status bits
uint8_t tidx = interp->parseTimerIndex(elem.tag);
LadderTimer& t = interp->getTimer(tidx);
switch (elem.type) {
case CT_TOF_DN: result = t.dn; break;
case CT_TOF_TT: result = t.tt; break;
case CT_TOF_EN: result = t.en; break;
default: result = false;
}
break;
}
case CT_TP_DN:
case CT_TP_TT:
case CT_TP_EN: {
// TP status bits
uint8_t tidx = interp->parseTimerIndex(elem.tag);
LadderTimer& t = interp->getTimer(tidx);
switch (elem.type) {
case CT_TP_DN: result = t.dn; break;
case CT_TP_TT: result = t.tt; break;
case CT_TP_EN: result = t.en; break;
default: result = false;
}
break;
}
default:
result = false;
break;
}
}
// For contacts, if any element fails, branch fails
if (!is_output && !result) {
power_flow = false;
break;
}
// For outputs, we've already handled the instruction
if (is_output) {
break;
}
}
return power_flow;
}
// ─────────────────────────────────────────────────────────────────────────────
// Network evaluation
// ─────────────────────────────────────────────────────────────────────────────
bool Network::evaluate(LadderInterpreter* interp) {
power_flow = false;
// ── Phase 1: Evaluate input branches (OR'd together) ─────────────────
// Any branch with power flow means the network has power
for (auto& branch : input_branches) {
if (branch.evaluate(interp, false)) {
power_flow = true;
break; // One branch is enough for OR logic
}
}
// ── Phase 2: If power flows, execute output branches ─────────────────
if (power_flow) {
for (auto& branch : output_branches) {
branch.power_flow = true; // Pass power to output branch
branch.evaluate(interp, true);
}
}
return power_flow;
}
// ─────────────────────────────────────────────────────────────────────────────
// LadderInterpreter constructor / destructor
// ─────────────────────────────────────────────────────────────────────────────
LadderInterpreter::LadderInterpreter()
: running(false), simulating(false), scan_start(0) {
// Zero out all arrays
for (int i = 0; i < MAX_DIGITAL_INPUTS; i++) {
di[i] = false;
}
for (int i = 0; i < MAX_DIGITAL_OUTPUTS; i++) {
do_[i] = false;
do_prev[i] = false;
}
for (int i = 0; i < MAX_BOOL_REGISTERS; i++) {
m_bool[i] = false;
}
for (int i = 0; i < MAX_INT_REGISTERS; i++) {
m_int[i] = 0;
}
for (int i = 0; i < MAX_TIMER_COUNT; i++) {
timers[i] = LadderTimer{
(uint8_t)i, 0, 0, false, false, false
};
}
for (int i = 0; i < MAX_COUNTER_COUNT; i++) {
counters[i] = LadderCounter{
(uint8_t)i, 0, 0, false, false, false, false, false, false
};
}
}
LadderInterpreter::~LadderInterpreter() {
}
// ─────────────────────────────────────────────────────────────────────────────
// Lifecycle
// ─────────────────────────────────────────────────────────────────────────────
void LadderInterpreter::begin() {
scan_start = millis();
Serial.println(F("MechBase PLC v2 — Ladder Interpreter Initialized"));
Serial.println(F("Instructions: NO NC Rising Falling | OTE OTL OTU | TON TOF TP"));
}
void LadderInterpreter::scan() {
if (!running) return;
scan_start = millis();
// Phase 1: Evaluate all networks (rung-by-rung)
for (auto& net : networks) {
net.evaluate(this);
}
// Phase 2: Update timers
// Timers are updated in the output branch evaluation,
// but we also need to track elapsed time per scan
for (auto& timer : timers) {
if (timer.tt) {
timer.elapsed = min(timer.elapsed + (millis() - scan_start),
(uint32_t)(timer.preset + 1));
}
}
// Phase 3: Update counters
for (auto& counter : counters) {
counter.update();
}
// Phase 4: Write physical outputs (skip in simulation)
if (!simulating) {
for (int i = 0; i < MAX_DIGITAL_OUTPUTS; i++) {
if (do_[i] != do_prev[i]) {
digitalWrite(i, do_[i] ? HIGH : LOW);
do_prev[i] = do_[i];
}
}
}
}
void LadderInterpreter::run() {
running = true;
Serial.println(F("PLC Running"));
}
void LadderInterpreter::stop() {
running = false;
Serial.println(F("PLC Stopped"));
}
// ─────────────────────────────────────────────────────────────────────────────
// I/O access
// ─────────────────────────────────────────────────────────────────────────────
void LadderInterpreter::setDI(uint8_t idx, bool val) {
if (idx < MAX_DIGITAL_INPUTS) di[idx] = val;
}
bool LadderInterpreter::getDI(uint8_t idx) {
if (idx < MAX_DIGITAL_INPUTS) return di[idx];
return false;
}
bool LadderInterpreter::getDO(uint8_t idx) {
if (idx < MAX_DIGITAL_OUTPUTS) return do_[idx];
return false;
}
void LadderInterpreter::setDO(uint8_t idx, bool val) {
if (idx < MAX_DIGITAL_OUTPUTS) do_[idx] = val;
}
// ─────────────────────────────────────────────────────────────────────────────
// Memory access
// ─────────────────────────────────────────────────────────────────────────────
void LadderInterpreter::setM(bool idx, bool val) {
// idx is a bool, cast to int for indexing
uint8_t i = (uint8_t)idx;
if (i < MAX_BOOL_REGISTERS) m_bool[i] = val;
}
bool LadderInterpreter::getM(bool idx) {
uint8_t i = (uint8_t)idx;
if (i < MAX_BOOL_REGISTERS) return m_bool[i];
return false;
}
void LadderInterpreter::setINT(uint8_t idx, int16_t val) {
if (idx < MAX_INT_REGISTERS) m_int[idx] = val;
}
int16_t LadderInterpreter::getINT(uint8_t idx) {
if (idx < MAX_INT_REGISTERS) return m_int[idx];
return 0;
}
// ─────────────────────────────────────────────────────────────────────────────
// Tag helpers — parse "I0", "Q0", "M0", "T0", "INT0", "T0.DN", "T0.TT", etc.
// ─────────────────────────────────────────────────────────────────────────────
bool LadderInterpreter::readBool(const char* tag) {
// Format: PREFIX[INDEX] or PREFIX[INDEX].BIT
// e.g. "I0", "Q3", "M10", "T0.DN", "T0.TT", "T0.EN"
if (tag[0] == 'I' || tag[0] == 'i') {
int idx = atoi(&tag[1]);
return getDI((uint8_t)idx);
}
if (tag[0] == 'Q' || tag[0] == 'q') {
int idx = atoi(&tag[1]);
return getDO((uint8_t)idx);
}
if (tag[0] == 'M' || tag[0] == 'm') {
int idx = atoi(&tag[1]);
return (bool)idx ? (idx < MAX_BOOL_REGISTERS && m_bool[idx]) : m_bool[0];
}
if (tag[0] == 'T' || tag[0] == 't') {
int idx = atoi(&tag[1]);
LadderTimer& t = getTimer((uint8_t)idx);
// Check for bit suffix
if (strlen(tag) > 2) {
const char* dot = strchr(tag, '.');
if (dot) {
if (strcmp(dot + 1, "DN") == 0) return t.dn;
if (strcmp(dot + 1, "TT") == 0) return t.tt;
if (strcmp(dot + 1, "EN") == 0) return t.en;
}
}
// Default: return DN bit
return t.dn;
}
if (tag[0] == 'C' || tag[0] == 'c') {
int idx = atoi(&tag[1]);
LadderCounter& c = getCounter((uint8_t)idx);
return c.dn;
}
return false;
}
void LadderInterpreter::writeBool(const char* tag, bool val) {
if (tag[0] == 'Q' || tag[0] == 'q') {
int idx = atoi(&tag[1]);
setDO((uint8_t)idx, val);
}
else if (tag[0] == 'M' || tag[0] == 'm') {
int idx = atoi(&tag[1]);
if (idx < MAX_BOOL_REGISTERS) m_bool[idx] = val;
}
// Timers/counters written by their own update logic
}
int16_t LadderInterpreter::readInt(const char* tag) {
if (tag[0] == 'I' && tag[1] == 'N') {
// INT0..INT31
int idx = atoi(&tag[3]);
return getINT((uint8_t)idx);
}
return 0;
}
void LadderInterpreter::writeInt(const char* tag, int16_t val) {
if (tag[0] == 'I' && tag[1] == 'N') {
int idx = atoi(&tag[3]);
setINT((uint8_t)idx, val);
}
}
uint8_t LadderInterpreter::parseTimerIndex(const char* tag) {
if (tag[0] == 'T' || tag[0] == 't') {
return (uint8_t)atoi(&tag[1]);
}
return 0;
}
uint8_t LadderInterpreter::parseCounterIndex(const char* tag) {
if (tag[0] == 'C' || tag[0] == 'c') {
return (uint8_t)atoi(&tag[1]);
}
return 0;
}
// ─────────────────────────────────────────────────────────────────────────────
// Timer / Counter access
// ─────────────────────────────────────────────────────────────────────────────
LadderTimer& LadderInterpreter::getTimer(uint8_t idx) {
if (idx < MAX_TIMER_COUNT) return timers[idx];
static LadderTimer dummy = {};
return dummy;
}
void LadderInterpreter::resetTimer(uint8_t idx) {
if (idx < MAX_TIMER_COUNT) timers[idx].reset();
}
LadderCounter& LadderInterpreter::getCounter(uint8_t idx) {
if (idx < MAX_COUNTER_COUNT) return counters[idx];
static LadderCounter dummy = {};
return dummy;
}
void LadderInterpreter::resetCounter(uint8_t idx) {
if (idx < MAX_COUNTER_COUNT) counters[idx].reset();
}
// ─────────────────────────────────────────────────────────────────────────────
// Program loading
// ─────────────────────────────────────────────────────────────────────────────
Network& LadderInterpreter::addNetwork(uint16_t num) {
Network net;
net.number = num;
net.power_flow = false;
networks.push_back(net);
return networks.back();
}
void LadderInterpreter::loadFromJSON(const char* json) {
// TODO: JSON parsing for program loading
Serial.println(F("loadFromJSON() called — JSON parser not yet implemented"));
}
// ─────────────────────────────────────────────────────────────────────────────
// Debug
// ─────────────────────────────────────────────────────────────────────────────
void LadderInterpreter::dumpState() {
Serial.println(F("=== PLC State Dump ==="));
Serial.print(F("Networks: ")); Serial.println(networks.size());
Serial.print(F("Running: ")); Serial.println(running ? "YES" : "NO");
Serial.print(F("Inputs (I0-I15): "));
for (int i = 0; i < MAX_DIGITAL_INPUTS; i++) {
Serial.print(di[i] ? '1' : '0');
Serial.print(' ');
}
Serial.println();
Serial.print(F("Outputs (Q0-Q15): "));
for (int i = 0; i < MAX_DIGITAL_OUTPUTS; i++) {
Serial.print(do_[i] ? '1' : '0');
Serial.print(' ');
}
Serial.println();
Serial.print(F("Memory (M0-M15): "));
for (int i = 0; i < 16; i++) {
Serial.print(m_bool[i] ? '1' : '0');
Serial.print(' ');
}
Serial.println();
Serial.print(F("Timers: "));
for (int i = 0; i < 4; i++) {
Serial.print(F("T")). print(i);
Serial.print(F("[EN=")). print(timers[i].en ? '1' : '0');
Serial.print(F(" TT=")). print(timers[i].tt ? '1' : '0');
Serial.print(F(" DN=")). print(timers[i].dn ? '1' : '0');
Serial.print(F(" el=")). print(timers[i].elapsed);
Serial.print(F(" pr=")). print(timers[i].preset);
Serial.print(F("] "));
}
Serial.println();
Serial.print(F("Scan: "));
Serial.print(getScanTime());
Serial.println(F("ms"));
}
// ─────────────────────────────────────────────────────────────────────────────
// Simulation mode
// ─────────────────────────────────────────────────────────────────────────────
void LadderInterpreter::enableSimulation() {
simulating = true;
Serial.println(F("Simulation mode enabled — GPIO writes disabled"));
}
void LadderInterpreter::disableSimulation() {
simulating = false;
Serial.println(F("Simulation mode disabled — GPIO writes active"));
}
bool LadderInterpreter::getSimulation() {
return simulating;
}