include/DebugLog.h

+#ifndef _DEBUG_LOG_H_
+#define _DEBUG_LOG_H_
+
+#include <Arduino.h>
+
+#ifdef PLATFORM_ESP
+#include <CircularBuffer.h>
+#define DEBUG_LOG_HISTORY_SIZE 1024
+#endif // PLATFORM_ESP
+
+class DebugLog {
+public:
+#ifdef PLATFORM_ESP
+    String getBuffer(void);
+#endif // PLATFORM_ESP
+    
+    void print(String s);
+    void print(int n);
+    
+    void println(void);
+    void println(String s);
+    void println(int n);
+    
+private:
+    void sendToTargets(String s);
+    
+#ifdef PLATFORM_ESP
+    void addToBuffer(String s);
+    
+    CircularBuffer<char, DEBUG_LOG_HISTORY_SIZE> buffer;
+#endif // PLATFORM_ESP
+};
+
+extern DebugLog debug;
+
+#endif // _DEBUG_LOG_H_

include/SerialLCD.h

     void clear(void);
     void setBacklight(uint8_t val);
     
+    void saveSplash(void);
+    void enableSplash(void);
+    void disableSplash(void);
+    
     // 0 no cursor, 1 underline, 2 blinking, 3 both
     void cursor(int style);
     

include/WifiStuff.h

 
 void wifi_set_message_buffer(String a, String b, String c, String d);
 void wifi_schedule_websocket(void);
-void wifi_send_websocket(void);
+void wifi_send_status_broadcast(void);
+
+void wifi_send_websocket(String s);
 
 #endif
 

include/config.h

 #define LED_CONNECT_BLINK_INTERVAL 250
 #define LED_ERROR_BLINK_INTERVAL 100
 
+#define INVERT_SENSOR_BOTTOM
+//#define INVERT_SENSOR_TOP
+
 #define OWN_I2C_ADDRESS 0x42
 #define I2C_BUS_SPEED 400000
 #define I2C_BUF_SIZE 32

include/config_pins.h

 #define SWITCH_COUNT 2
 #define SWITCH_PINS 22, 23
 
+#define I2C_SDA_PIN 21
+#define I2C_SCL_PIN 22
+
 #endif // FUNCTION_CONTROL
 
 #endif // PLATFORM_ESP

platformio.ini

 lib_deps =
     Wire
     https://github.com/Links2004/arduinoWebSockets
+    https://github.com/rlogiacco/CircularBuffer
 
 [env:esp32_main]
 platform = espressif32
 lib_deps =
     Wire
     https://github.com/Links2004/arduinoWebSockets
+    https://github.com/rlogiacco/CircularBuffer
 
 [env:arduino_ui]
 platform = atmelavr

src/DebugLog.cpp

+#include <Arduino.h>
+
+#ifdef PLATFORM_ESP
+#include "WifiStuff.h"
+#endif // PLATFORM_ESP
+
+#include "DebugLog.h"
+
+DebugLog debug;
+
+#ifdef PLATFORM_ESP
+
+String DebugLog::getBuffer(void) {
+    String r;
+    for (unsigned int i = 0; i < buffer.size(); i++) {
+        r += buffer[i];
+    }
+    return r;
+}
+
+void DebugLog::addToBuffer(String s) {
+    for (unsigned int i = 0; i < s.length(); i++) {
+        buffer.push(s[i]);
+    }
+}
+
+#endif // PLATFORM_ESP
+
+void DebugLog::sendToTargets(String s) {
+    Serial.print(s);
+    
+#ifdef PLATFORM_ESP
+    s = "log:" + s;
+    wifi_send_websocket(s);
+#endif // PLATFORM_ESP
+}
+
+void DebugLog::print(String s) {
+#ifdef PLATFORM_ESP
+    addToBuffer(s);
+#endif // PLATFORM_ESP
+    
+    sendToTargets(s);
+}
+
+void DebugLog::print(int n) {
+    print(String(n));
+}
+
+void DebugLog::println(void) {
+    print(String('\n'));
+}
+
+void DebugLog::println(String s) {
+    s += '\n';
+    print(s);
+}
+
+void DebugLog::println(int n) {
+    println(String(n));
+}

src/Functionality.cpp

 
 #include "config.h"
 #include "config_pins.h"
+#include "DebugLog.h"
 #include "Functionality.h"
 
 #ifdef FUNCTION_UI
 
 void ui_i2c_request(void) {
     if (keybuffer.isEmpty()) {
-        Wire.write(-4);
+        Wire.write(252);
         return;
     }
     
-    Serial.print("ui_i2c_request: ");
+    debug.print("ui_i2c_request: ");
     
     while (!keybuffer.isEmpty()) {
         int n = keybuffer.shift();
         
-        // for some reason it seems as if we always get -1 here,
-        // so we cant send our input (-2 to 9) as is.
-        // so -4 is no-data, -3 is -1, and the rest as-is.
         if (n == -1) {
-            n = -3;
+            n = 254;
+        } else if (n == -2) {
+            n = 253;
+        } else if ((n < 0) || (n > 9)) {
+            continue;
         }
         
-        Serial.print(n);
-        Serial.print(", ");
+        debug.print(n);
+        debug.print(", ");
         
         Wire.write(n);
     }
     
-    Serial.println();
+    debug.println();
 }
 
 void ui_i2c_receive(int count) {
     }
     
     if (count <= 0) {
-        Serial.println("ui_i2c_receive: count is 0");
+        debug.println("ui_i2c_receive: count is 0");
         return;
     }
     
     if (buff[0] == 0x01) {
         if (count < 3) {
-            Serial.println("ui_i2c_receive: blink lcd too short");
+            debug.println("ui_i2c_receive: blink lcd too short");
             return;
         }
         
         int n = buff[1];
         int wait = buff[2] * 10;
         
-        Serial.println("ui_i2c_receive: blink lcd command");
+        debug.println("ui_i2c_receive: blink lcd command");
         blink_lcd(n, wait);
     } else if (buff[0] == 0x02) {
-        Serial.println("ui_i2c_receive: backspace command");
+        debug.println("ui_i2c_receive: backspace command");
         backspace();
     } else if (buff[0] == 0x03) {
         if (count < 3) {
-            Serial.println("ui_i2c_receive: display far too short");
+            debug.println("ui_i2c_receive: display far too short");
             return;
         }
         
             s += buff[3 + i];
         }
         
-        Serial.println("ui_i2c_receive: display command");
+        debug.println("ui_i2c_receive: display command");
         linebuffer[line] = s;
     } else if (buff[0] == 0x04) {
         if (count < 2) {
-            Serial.println("ui_i2c_receive: num input too short");
+            debug.println("ui_i2c_receive: num input too short");
             return;
         }
         
         int8_t num_input = buff[1];
         
-        Serial.println("ui_i2c_receive: num input");
+        debug.println("ui_i2c_receive: num input");
         write_to_all(linebuffer[0].c_str(), linebuffer[1].c_str(),
                      linebuffer[2].c_str(), linebuffer[3].c_str(),
                      num_input);
     } else {
-        Serial.println("ui_i2c_receive: unknown command");
+        debug.println("ui_i2c_receive: unknown command");
         return;
     }
 }
 void ui_setup(void) {
     keys.setPins(keymatrix_pins);
     
-    Serial.println("Setting up LCD, please wait");
+    debug.println("Setting up LCD, please wait");
     delay(1000); // give LCD some time to boot
     lcd.init();
+    lcd.disableSplash();
     
 #ifdef DEBUG_WAIT_FOR_SERIAL_CONN
     lcd.write(0, "Waiting for serial");
 #endif // DEBUG_WAIT_FOR_SERIAL_CONN
     
 #ifndef FUNCTION_CONTROL
-    Serial.println("Initializing I2C Slave");
+    debug.println("Initializing I2C Slave");
     Wire.begin(OWN_I2C_ADDRESS);
     Wire.onReceive(ui_i2c_receive);
     Wire.onRequest(ui_i2c_request);
             }
             
             int n = ke.getNum();
-            Serial.print("Got keypad input: \"");
+            debug.print("Got keypad input: \"");
             
             if (n < 0) {
-                Serial.print((n == -1) ? '*' : '#');
+                debug.print((n == -1) ? '*' : '#');
             } else {
-                Serial.print(n);
+                debug.print(n);
                 
                 if (doing_multi_input) {
                     char s[2] = { (char)(n + '0'), '\0' };
                 }
             }
             
-            Serial.println("\"");
+            debug.println("\"");
             
             blink_lcd(1, 100);
             handle_input(n);
     
 #ifndef FUNCTION_UI
     
-    Serial.println("Initializing I2C Master");
+    debug.println("Initializing I2C Master");
     Wire.setClock(I2C_BUS_SPEED);
+    
+#if defined(I2C_SDA_PIN) && defined(I2C_SCL_PIN)
+    Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
+#else
     Wire.begin();
+#endif // defined(I2C_SDA_PIN) && defined(I2C_SCL_PIN)
     
 #ifdef DEBUG_WAIT_FOR_SERIAL_CONN
-    Serial.println("Wait for Serial");
+    debug.println("Wait for Serial");
     while (!Serial);
 #endif // DEBUG_WAIT_FOR_SERIAL_CONN
     
     
     Wire.requestFrom(OWN_I2C_ADDRESS, I2C_BUF_SIZE);
     while (Wire.available()) {
-        char c = Wire.read();
+        int c = Wire.read();
         
-        // for some reason it seems as if we always get -1 here,
-        // so we cant send our input (-2 to 9) as is.
-        // so -4 is no-data, -3 is -1, and the rest as-is.
-        if ((c >= -3) && (c <= 9) && (c != -1)) {
-            if (c == -3) {
+        if (((c >= 0) && (c <= 9)) || (c == 254) || (c == 253)) {
+            debug.print("control_run: got input '");
+            debug.print(c);
+            debug.println("'");
+            
+            if (c == 254) {
                 c = -1;
+            } else if (c == 253) {
+                c = -2;
             }
         
-            Serial.print("control_run: got input '");
-            Serial.print((int)c);
-            Serial.println("'");
-        
             sm.input(c);
         }
     }
 #ifndef FUNCTION_UI
 
 void blink_lcd(int n, int wait) {
-    Serial.println("blink_lcd i2c");
+    debug.println("blink_lcd i2c");
     
     Wire.beginTransmission(OWN_I2C_ADDRESS);
     Wire.write(0x01); // blink command
 }
 
 void backspace(void) {
-    Serial.println("backspace i2c");
+    debug.println("backspace i2c");
     
     Wire.beginTransmission(OWN_I2C_ADDRESS);
     Wire.write(0x02); // backspace command
                   const char *c, const char *d, int num_input) {
     const char *lines[4] = { a, b, c, d };
     
-    Serial.println("write_to_all i2c");
+    debug.println("write_to_all i2c");
     
     for (int i = 0; i < 4; i++) {
         Wire.beginTransmission(OWN_I2C_ADDRESS);
     
     write_lcd_to_serial(a, b, c, d);
     
+#ifdef PLATFORM_ESP
     wifi_set_message_buffer(a, b, c, d);
-    wifi_send_websocket();
+    wifi_send_status_broadcast();
+#endif // PLATFORM_ESP
 }
 
 #endif // ! FUNCTION_UI

src/Keymatrix.cpp

 
 //#define DEBUG_PRINT_MATRIX_STATE
 
+#ifdef DEBUG_PRINT_MATRIX_STATE
+#include "DebugLog.h"
+#endif // DEBUG_PRINT_MATRIX_STATE
+
 Keymatrix::Event::Event(EventType _type, int _row, int _col) {
     type = _type;
     row = _row;
     
 #ifdef DEBUG_PRINT_MATRIX_STATE
     for (int i = 0; i < buttons; i++) {
-        Serial.print(pressed[i] ? "1" : "0");
+        debug.print(pressed[i] ? "1" : "0");
         if (i < (buttons - 1)) {
-            Serial.print(" ");
+            debug.print(" ");
         } else {
-            Serial.println();
+            debug.println();
         }
     }
-#endif
+#endif // DEBUG_PRINT_MATRIX_STATE
     
     for (int i = 0; i < buttons; i++) {
         // debounce - compare to previous state

src/Plants.cpp

 #include <Arduino.h>
+
+#include "DebugLog.h"
 #include "Plants.h"
+#include "config.h"
+#include "config_pins.h"
     
 // valves: no of plants + 1 for water inlet
 // pumps: no of fertilizers
     bool low = switches.getPin(0);
     bool high = switches.getPin(1);
     
+#ifdef INVERT_SENSOR_BOTTOM
+    low = !low;
+#endif // INVERT_SENSOR_BOTTOM
+    
+#ifdef INVERT_SENSOR_TOP
+    high = !high;
+#endif // INVERT_SENSOR_TOP
+    
     if ((!low) && (!high)) {
         return empty;
     } else if (low && (!high)) {
 }
 
 void Plants::openWaterInlet(void) {
-    Serial.println("Plants::openWaterInlet");
+    debug.println("Plants::openWaterInlet");
     valves.setPin(countPlants(), true);
 }
 
 void Plants::closeWaterInlet(void) {
-    Serial.println("Plants::closeWaterInlet");
+    debug.println("Plants::closeWaterInlet");
     valves.setPin(countPlants(), false);
 }
 
 }
 
 void Plants::startFertilizer(int id) {
-    Serial.print("Plants::startFertilizer ");
-    Serial.println(id);
+    debug.print("Plants::startFertilizer ");
+    debug.println(id);
     
     if ((id >= 0) && (id < countFertilizers())) {
         pumps.setPin(id, true);
 }
 
 void Plants::stopFertilizer(int id) {
-    Serial.print("Plants::stopFertilizer ");
-    Serial.println(id);
+    debug.print("Plants::stopFertilizer ");
+    debug.println(id);
     
     if ((id >= 0) && (id < countFertilizers())) {
         pumps.setPin(id, false);
 }
 
 void Plants::startPlant(int id) {
-    Serial.print("Plants::startPlant ");
-    Serial.println(id);
+    debug.print("Plants::startPlant ");
+    debug.println(id);
     
     if ((id >= 0) && (id < countPlants())) {
         valves.setPin(id, true);
 }
 
 void Plants::stopPlant(int id) {
-    Serial.print("Plants::stopPlant ");
-    Serial.println(id);
+    debug.print("Plants::stopPlant ");
+    debug.println(id);
     
     if ((id >= 0) && (id < countPlants())) {
         valves.setPin(id, false);

src/SerialLCD.cpp

+// see https://github.com/sparkfun/SparkFun_SerLCD_Arduino_Library
+
 #include <Arduino.h>
 #include "SerialLCD.h"
 
     delay(LCD_DELAY);
 }
 
+void SerialLCD::saveSplash(void) {
+    lcd->write(0x7C);
+    lcd->write(0x0A);
+}
+
+void SerialLCD::enableSplash(void) {
+    lcd->write(0x7C);
+    lcd->write(0x30);
+}
+
+void SerialLCD::disableSplash(void) {
+    lcd->write(0x7C);
+    lcd->write(0x31);
+}
 void SerialLCD::write(const char *text) {
     lcd->print(text);
     delay(LCD_DELAY);

src/Statemachine.cpp

 #include "Plants.h"
+#include "DebugLog.h"
 #include "Statemachine.h"
 #include "config.h"
 
     uint32_t n = db.getNumber();
     db.clear();
     
-    Serial.print("Whole number input: ");
-    Serial.println(n);
+    debug.print("Whole number input: ");
+    debug.println(n);
     
     return n;
 }

src/WifiStuff.cpp

 #include "config_pins.h"
 #include "Functionality.h"
 #include "SimpleUpdater.h"
+#include "DebugLog.h"
 #include "WifiStuff.h"
 
 UPDATE_WEB_SERVER server(80);
     last_websocket_update_time = 0;
 }
 
-void wifi_send_websocket(void) {
+void wifi_send_status_broadcast(void) {
+    if (socket.connectedClients() <= 0) {
+        return;
+    }
+    
     String a = message_buffer_a ;
     String b = message_buffer_b;
     String c = message_buffer_c;
     
     ws += F("\"switches\": [ ");
     for (int i = 0; i < SWITCH_COUNT; i++) {
+        bool v = get_plants()->getSwitches()->getPin(i);
+        
+#ifdef INVERT_SENSOR_BOTTOM
+        if (i == 0) {
+            v = !v;
+        }
+#endif // INVERT_SENSOR_BOTTOM
+        
+#ifdef INVERT_SENSOR_TOP
+        if (i == 1) {
+            v = !v;
+        }
+#endif // INVERT_SENSOR_TOP
+
         ws += "\"";
-        ws += get_plants()->getSwitches()->getPin(i) ? "1" : "0";
+        ws += v ? "1" : "0";
         ws += "\"";
         
         if (i < (SWITCH_COUNT - 1)) {
     ws += "\"\n";
     ws += "}";
     
-    socket.broadcastTXT(ws);
+    wifi_send_websocket(ws);
+}
+
+void wifi_send_websocket(String s) {
+    socket.broadcastTXT(s);
 }
 
 void handleRoot() {
     message += F("font-family: monospace;\n");
     message += F("}\n");
     
+    message += F(".log {\n");
+    message += F("max-height: 300px;\n");
+    message += F("padding: 0 1.0em;\n");
+    message += F("margin: 1em 0;\n");
+    message += F("border: 1px dashed black;\n");
+    message += F("font-family: monospace;\n");
+    message += F("overflow-y: scroll;\n");
+    message += F("word-break: break-all;\n");
+    message += F("}\n");
+    
+    message += F("#logbuf {\n");
+    message += F("white-space: break-spaces;\n");
+    message += F("}\n");
+    
     message += F(".pad {\n");
     message += F("background: black;\n");
     message += F("border: 3px solid black;\n");
     message += F("<div class='container'>\n");
     for (int i = 0; i < SWITCH_COUNT; i++) {
         message += F("<div class='switch' style='background-color: ");
-        if (get_plants()->getSwitches()->getPin(i)) {
+        bool v = get_plants()->getSwitches()->getPin(i);
+        
+#ifdef INVERT_SENSOR_BOTTOM
+        if (i == 0) {
+            v = !v;
+        }
+#endif // INVERT_SENSOR_BOTTOM
+        
+#ifdef INVERT_SENSOR_TOP
+        if (i == 1) {
+            v = !v;
+        }
+#endif // INVERT_SENSOR_TOP
+        
+        if (v) {
             message += F("red");
         } else {
             message += F("green");
     message += F("<p>Try <a href='/update'>/update</a> for OTA firmware updates!</p>\n");
     message += F("<p>Made by <a href='https://xythobuz.de'>xythobuz</a></p>\n");
     message += F("<p><a href='https://git.xythobuz.de/thomas/giess-o-mat'>Project Repository</a></p>\n");
-    message += F("</div>\n");
-    message += F("</div></body>\n");
+    message += F("</div></div>\n");
+    
+    message += F("<div class='log'><pre id='logbuf'>\n");
+    message += debug.getBuffer();
+    message += F("</pre></div>\n");
+    message += F("</body>\n");
     
     message += F("<script type='text/javascript'>\n");
     message += F("var socket = new WebSocket('ws://' + window.location.hostname + ':81');\n");
     message += F("socket.onmessage = function(e) {\n");
+    message += F(    "if (e.data.startsWith('log:')) {\n");
+    message += F(        "var log = document.getElementById('logbuf');\n");
+    message += F(        "var div = document.getElementsByClassName('log')[0];\n");
+    message += F(        "log.innerHTML += e.data.substring(4);\n");
+    message += F(        "if (log.innerHTML.length > (1024 * 1024)) {\n");
+    message += F(            "log.innerHTML = log.innerHTML.substring(1024 * 1024);\n");
+    message += F(        "}\n");
+    message += F(        "div.scrollTop = div.scrollHeight;\n");
+    message += F(        "return;\n");
+    message += F(    "}\n");
     message += F(    "var msg = JSON.parse(e.data);\n");
     message += F(    "var str = msg.a + '\\n' + msg.b + '\\n' + msg.c + '\\n' + msg.d;\n");
     message += F(    "console.log(str);\n");
 #if defined(ARDUINO_ARCH_ESP8266)
 
     // Connect to WiFi AP
-    Serial.println("WiFi: initializing");
+    debug.println("WiFi: initializing");
     WiFi.hostname(hostname);
     WiFi.mode(WIFI_STA);
     
-    Serial.print("WiFi: connecting");
+    debug.print("WiFi: connecting");
     WiFi.begin(WIFI_SSID, WIFI_PW);
     while (WiFi.status() != WL_CONNECTED) {
-        Serial.print(".");
+        debug.print(".");
         delay(LED_CONNECT_BLINK_INTERVAL);
         digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
     }
-    Serial.println();
+    debug.println();
     
 #elif defined(ARDUINO_ARCH_ESP32)
 
     // Set hostname workaround
-    Serial.println("WiFi: set hostname");
+    debug.println("WiFi: set hostname");
     WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE);
     WiFi.setHostname(hostname.c_str());
     
     // Workaround for WiFi connecting only every 2nd reset
     // https://github.com/espressif/arduino-esp32/issues/2501#issuecomment-513602522
-    Serial.println("WiFi: connection work-around");
+    debug.println("WiFi: connection work-around");
     WiFi.onEvent([](WiFiEvent_t event, WiFiEventInfo_t info) {
         if (info.disconnected.reason == 202) {
             esp_sleep_enable_timer_wakeup(10);
     }, WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
 
     // Connect to WiFi AP
-    Serial.println("WiFi: SSID=" WIFI_SSID);
-    Serial.print("WiFi: connecting");
+    debug.println("WiFi: SSID=" WIFI_SSID);
+    debug.print("WiFi: connecting");
     WiFi.mode(WIFI_STA);
     WiFi.begin(WIFI_SSID, WIFI_PW);
     while (WiFi.status() != WL_CONNECTED) {
-        Serial.print(".");
+        debug.print(".");
         delay(LED_CONNECT_BLINK_INTERVAL);
         digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
     }
-    Serial.println();
+    debug.println();
     
     // Set hostname workaround
-    Serial.println("WiFi: set hostname work-around");
+    debug.println("WiFi: set hostname work-around");
     WiFi.setHostname(hostname.c_str());
 
 #endif
 
     // Setup HTTP Server
-    Serial.println("WiFi: initializing HTTP server");
+    debug.println("WiFi: initializing HTTP server");
     MDNS.begin(hostname.c_str());
     updater.setup(&server);
     server.on("/", handleRoot);
     socket.begin();
     socket.onEvent(webSocketEvent);
     
-    Serial.println("WiFi: setup done");
+    debug.println("WiFi: setup done");
 }
 
 void wifi_run() {
     
     if ((millis() - last_websocket_update_time) >= WEBSOCKET_UPDATE_INTERVAL) {
         last_websocket_update_time = millis();
-        wifi_send_websocket();
+        wifi_send_status_broadcast();
     }
     
     // reset ESP every 6h to be safe

src/main.cpp

 
 #include "Functionality.h"
 #include "WifiStuff.h"
+#include "DebugLog.h"
 #include "config.h"
 #include "config_pins.h"
 
     digitalWrite(BUILTIN_LED_PIN, HIGH);
     
     Serial.begin(115200);
-    Serial.println("Initializing Giess-o-mat");
-    Serial.println("Version: " FIRMWARE_VERSION);
+    debug.println("Initializing Giess-o-mat");
+    debug.println("Version: " FIRMWARE_VERSION);
 
 #ifdef FUNCTION_UI
-    Serial.println("Initializing UI");
+    debug.println("Initializing UI");
     ui_setup();
 #endif // FUNCTION_UI
     
 #ifdef FUNCTION_CONTROL
-    Serial.println("Initializing Control");
+    debug.println("Initializing Control");
     control_setup();
 #endif // FUNCTION_CONTROL
     
 #ifdef PLATFORM_ESP
-    Serial.println("Initializing WiFi");
+    debug.println("Initializing WiFi");
     wifi_setup();
 #endif // PLATFORM_ESP
     
-    Serial.println("Ready, starting main loop");
+    debug.println("Ready, starting main loop");
     digitalWrite(BUILTIN_LED_PIN, LOW);
     
 #ifdef FUNCTION_CONTROL
     
 #ifndef FUNCTION_UI
     // give ui unit some time to initialize
-    Serial.println("Waiting for UI to boot");
+    debug.println("Waiting for UI to boot");
     delay(3000);
 #endif // ! FUNCTION_UI
     
-    Serial.println("Starting state machine");
+    debug.println("Starting state machine");
     control_begin();
     
 #endif // FUNCTION_CONTROL