// ===================================================
// = Kever instrumenten                              =
// = Snelheidsmeter, toerenteller, info, etc         =
// = Keuze d.m.v. een draaischakelaar en een menu    =
// = op het OLED-scherm.                             =                                     =
// =                                                 =
// =  Auteur: Richard Lagendijk                      =
// =  Info:   www.richardlagendijk.nl                =
// =  Datum:  2026-10-07                             =
// =  Versie: 1.0                                    =
// ===================================================

// ===================================================
// = Includes                                        =
// ===================================================
#include "Arduino.h"
#include "string.h"
#include <SSD1306.h>

OLED oled(128, 64);

// ===================================================
// = Initialisatie                                   =
// ===================================================
// Defineer de pinnen (ingangen)
#define REM PB3
#define LINKS PB4
#define RECHTS PB5
#define KEUZE_KLOK PA6
#define KEUZE_DATA PA7
#define KEUZE_SCHAKELAAR PB9
#define GROOT PB8
#define AUDIO_LINKS PB0
#define AUDIO_RECHTS PB1
// Defineer de pinnen (uitgangen)
#define LED_1 PB10
#define LED_2 PB11
#define LED_3 PB12
#define LED_4 PA0
#define LED_5 PA1
#define LED_6 PA2
#define LED_7 PA3
#define LED_8 PA4
#define LED_9 PA5
#define LED_10 PA12
#define LED_11 PA15
#define LED_12 PB13
#define LED_13 PB14
#define LED_14 PB15
#define VOOR_27 PA9
#define ACHTER_27 PA11
#define VOOR_18 PA8
#define ACHTER_18 PA10
#define KNIPPER_LINKS PC14
#define KNIPPER_RECHTS PC15
#define LED_PCB PC13

void setup() {
  // Pin is een ingang of een uitgang
  pinMode(AUDIO_LINKS, INPUT);
  pinMode(AUDIO_RECHTS, INPUT);
  pinMode(REM, INPUT);
  pinMode(LINKS, INPUT);
  pinMode(RECHTS, INPUT);
  pinMode(GROOT, INPUT);
  pinMode(KEUZE_KLOK, INPUT);
  pinMode(KEUZE_DATA, INPUT);
  pinMode(KEUZE_SCHAKELAAR, INPUT);
  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
  pinMode(LED_3, OUTPUT);
  pinMode(LED_4, OUTPUT);
  pinMode(LED_5, OUTPUT);
  pinMode(LED_6, OUTPUT);
  pinMode(LED_7, OUTPUT);
  pinMode(LED_8, OUTPUT);
  pinMode(LED_9, OUTPUT);
  pinMode(LED_10, OUTPUT);
  pinMode(LED_11, OUTPUT);
  pinMode(LED_12, OUTPUT);
  pinMode(LED_13, OUTPUT);
  pinMode(LED_14, OUTPUT);
  pinMode(VOOR_27, OUTPUT);
  pinMode(ACHTER_27, OUTPUT);
  pinMode(VOOR_18, OUTPUT);
  pinMode(ACHTER_18, OUTPUT);
  pinMode(KNIPPER_LINKS, OUTPUT);
  pinMode(KNIPPER_RECHTS, OUTPUT);
  pinMode(LED_PCB, OUTPUT);

  // ===================================================
  // = Interupt voor keuze schakelaar.                 =
  // ===================================================
  attachInterrupt(digitalPinToInterrupt(KEUZE_KLOK), leesKeuze, FALLING);

  // ===================================================
  // = Opstart scherm                                  =
  // ===================================================
  oled.begin();
  oled.clearScr();
  oled.rectangle(0, 0, 128, 64, 0, 1, false);
  oled.print("Richard Lagendijk", 14, 15);
  oled.print("V1.00 - 2026", 30, 40);
  oled.inflate();
  delay(4000);

}

// ===================================================
// = Globale variabelen                              =
// ===================================================
int iRemLicht                 = 0;
int iAudioLinks               = 0;
int iAudioRechts              = 0;
int iGrootLicht               = 0;
int iIngangen                 = 0;
int iIngangen_Vorige          = 0;
int iKnipperLinks             = 0;
int iKnipperRechts            = 0;
int iKeuzeSchakelaar          = 0;
int iLEDs                     = 0;
int iLEDs_Voor_18             = 0;
int iLEDs_Voor_27             = 0;
int iLEDs_Achter_18           = 0;
int iLEDs_Achter_27           = 0;
int iKnipperLamp_Links        = 0;
int iKnipperLamp_Rechts       = 0;
int iKeuze                    = 0;  // Actuele keuze voor de effecten.
int iKeuzeScherm              = 0;  // Actuele keuze op het OLED scherm.
int iKeuzeScherm_Vorige       = 99;
int iMultiKnipperLinks        = 0;
int iMultiKnipperRechts       = 0;
int iMultiKnipperTel          = 0;
int iKeuze_Data               = 0;
int iTel                      = 0;
int iLEDs_StatusPositie       = 0;
int iLEDs_StatusVoor          = 0;
int iLEDs_StatusVoor_Vorige   = 0;
int iLEDs_StatusAchter        = 0;
int iLEDs_StatusAchter_Vorige = 0;
int aBin[]                    = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536};

int aEffect[][40]             = { {125, 14, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 256, 128, 64, 32, 16}, // Kitt scanner Achter.
                                  {125, 14, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 256, 128, 64, 32, 16}, // Kitt scanner Voor.
                                  {125, 14, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 256, 128, 64, 32, 16}, // Kitt scanner Achter en Voor.
                                  {500,  2, 13107, 3276},       // Om en Om knipperen.
                                  {500,  2, 16383, 0},          // Alles Knipperen.
                                  {500,  2, 14343, 2040},       // Buiten Midden knipperen.
                                  {500,  2, 16256, 127},        // Links Rechts knipperen.
                                  {200,  3, 9362, 4681, 2340},  // Naar Rechts looplicht.
                                  {200,  3, 4681, 9362, 2340},  // Naar Links looplicht.
                                  {100, 14, 192, 480, 816, 1560, 1032, 0, 14343, 0, 14343, 0, 14343, 0, 0, 0}, // Vuurpijl
                                  {100, 20, 12291, 3084, 816, 480, 12771, 3564, 1008, 13299, 4092, 16383, 4092, 13299, 1008, 3564, 12771, 480, 816, 3084, 12291, 0}, // Vullen Legen
                                  {100, 28, 8256, 4128, 2064, 1032, 516, 258, 129, 8256, 4128, 2064, 1032, 516, 258, 129, 129, 258, 516, 1032, 2064, 4128, 8256, 129, 258, 516, 1032, 2064, 4128, 8256}, // Looplicht
                                  {100, 14, 192, 480, 1008, 2040, 4092, 8190, 16383, 8190, 4092, 2040, 1008, 480, 192, 0}, // Dun Dik
                                  {100, 14, 8193, 12291, 14343, 15375, 15903, 16191, 16383, 16191, 15903, 15375, 14343, 12291, 8193, 0}, // Dik Dun
                                  {300, 34, 16383, 0, 16383, 0, 16383, 0, 0, 0, 16383, 16383, 16383, 0, 16383, 16383, 16383, 0, 16383, 16383, 16383, 0, 0, 0, 16383, 0, 16383, 0, 16383, 0, 0, 0, 0, 0, 0, 0} }; // SOS 
int iEffectTijd               = millis();
int iEffectStap               = 0;

int aKnipperLinks[][14]       = { {125, 12, 14336, 14336, 14336, 14336, 14336, 14336, 0, 0, 0, 0, 0, 0},
                                  {125, 12,  2048,  6144, 14336, 14336, 14336, 14336, 0, 0, 0, 0, 0, 0},
                                  {125, 12,  2048,  6144, 14336, 14336, 12288,  8192, 0, 0, 0, 0, 0, 0} };
int aKnipperRechts[][14]      = { {125, 12,     7,     7,     7,     7,     7,     7, 0, 0, 0, 0, 0, 0},
                                  {125, 12,     4,     6,     7,     7,     7,     7, 0, 0, 0, 0, 0, 0},
                                  {125, 12,     4,     6,     7,     7,     3,     1, 0, 0, 0, 0, 0, 0} };
int iKnipperTijd              = millis();
int iKnipperStap              = 0;
int iKnipperSoort             = 2;

int aRem[][12]                = { {100, 10, 2040, 2040, 2040, 2040, 2040, 2040, 2040, 2040, 2040, 2040},
                                  {100, 10,  192,  480, 1008, 2040,    0, 2040,    0, 2040,    0, 2040} };
int iRemTijd                  = millis();
int iRemStap                  = 0;
int iRemSoort                 = 1;

char sLEDs_StatusVoor[]       = "______________";
char sLEDs_StatusAchter[]     = "______________";
char sScherm_Regel_1[]        = "Regel 1           ";
char sScherm_Regel_2[]        = "Regel 2           ";
char sScherm_Regel_3[]        = "Regel 3           ";
char aScherm_Menu[][19]       = {"---               ",
                                "Alles uit         ",  // Keuze == 0
                                "Dagrijverlichting ",  // Keuze == 1
                                "Scanner Achter    ",  // Keuze == 2
                                "Scanner Voor      ",  // Keuze == 3
                                "Scanner A + V     ",  // Keuze == 4
                                "Knipperen OmEnOm  ",  // Keuze == 5
                                "Knipperen Alles   ",  // Keuze == 6
                                "Knipperen Bu/Mi   ",  // Keuze == 7
                                "Knipperen Li/Re   ",  // Keuze == 8
                                "Naar Rechts       ",  // Keuze == 9
                                "Naar Links        ",  // Keuze == 10
                                "Vuurpijlen        ",  // Keuze == 11
                                "Vullen en Legen   ",  // Keuze == 12
                                "Looplicht         ",  // Keuze == 13
                                "Dun Dik           ",  // Keuze == 14
                                "Dik Dun           ",  // Keuze == 15
                                "S.O.S.            ",  // Keuze == 16
                                "Audio  L+R        ",  // Keuze == 17
                                "Knipper standaard ",  // Keuze == 18
                                "Knipper 1x loop   ",  // Keuze == 19
                                "Knipper 2x loop   ",  // Keuze == 20
                                "Rem standaard     ",  // Keuze == 21
                                "Rem met effect    ",  // Keuze == 22
                                "-----             "};

// ===================================================
// = Inlezen keuzeschakelaar (via interrupt)         =
// ===================================================
void leesKeuze() {
  iKeuze_Data = digitalRead(KEUZE_DATA);
  if (iKeuze_Data == HIGH) { iKeuzeScherm++; }  // Keuzeknop draait met de klok mee.}
  if (iKeuze_Data == LOW)  { iKeuzeScherm--; }  // Keuzeknop draait tegen deklok in.}
  if (iKeuzeScherm < 0) {iKeuzeScherm = 0;}     // Minimum keuze.
  if (iKeuzeScherm > 22) {iKeuzeScherm = 22;}   // Maximum keuze.
  iEffectStap = 0;                              // Bij wisselen van keuze stap voor effect altijd op begin stap (=1).
  iEffectTijd = millis();
}

void loop() {

  while (1) {

    // Lees de status van de ingangen.
    iRemLicht        = digitalRead(REM);
    iGrootLicht      = digitalRead(GROOT);
    iKnipperLinks    = digitalRead(LINKS);
    iKnipperRechts   = digitalRead(RECHTS);
    iKeuzeSchakelaar = digitalRead(KEUZE_SCHAKELAAR);
    iIngangen        = iRemLicht + (iGrootLicht * 2) + (iKnipperLinks * 4) + (iKnipperRechts * 8);

    // Effecten
    if ((iKeuze > 1) && (iKeuze < 18)) {
      // Update de LEDs met de data van het huidige effect.
      iLEDs = aEffect[iKeuze - 2][iEffectStap + 2];
      // Controleer voor volgende stap.
      if (millis() > (iEffectTijd + aEffect[iKeuze - 2][0])) {
        iEffectStap++;
        iEffectTijd = millis();
      }
      // Controleer of laatste stap van het effect is bereikt.
      if (iEffectStap > (aEffect[iKeuze - 2][1] - 1)) { iEffectStap = 0; }
      // LED's voor en achter aan.
      iLEDs_Voor_18   = 1;
      iLEDs_Achter_18 = 1;
      iLEDs_Voor_27   = 1;
      iLEDs_Achter_27 = 1;
      // Uitzonderingen voor Kitt scanners.
      if (iKeuze == 2) {iLEDs_Voor_18   = 0; iLEDs_Voor_27   = 0;}
      if (iKeuze == 3) {iLEDs_Achter_18 = 0; iLEDs_Achter_27 = 0;}
    }

    // Audio VU-meters.
    if (iKeuze == 17) {
      // Update de LEDs met de data van het huidige effect.
      iLEDs = 0;

      iAudioLinks = analogRead(AUDIO_LINKS);
      if (iAudioLinks >  25) {iLEDs = iLEDs |  128;}
      if (iAudioLinks > 175) {iLEDs = iLEDs |  256;}
      if (iAudioLinks > 325) {iLEDs = iLEDs |  512;}
      if (iAudioLinks > 475) {iLEDs = iLEDs | 1024;}
      if (iAudioLinks > 625) {iLEDs = iLEDs | 2048;}
      if (iAudioLinks > 775) {iLEDs = iLEDs | 4096;}
      if (iAudioLinks > 925) {iLEDs = iLEDs | 8192;}

      iAudioLinks = analogRead(AUDIO_RECHTS);
      if (iAudioRechts >  25) {iLEDs = iLEDs | 64;}
      if (iAudioRechts > 175) {iLEDs = iLEDs | 32;}
      if (iAudioRechts > 325) {iLEDs = iLEDs | 16;}
      if (iAudioRechts > 475) {iLEDs = iLEDs |  8;}
      if (iAudioRechts > 625) {iLEDs = iLEDs |  4;}
      if (iAudioRechts > 775) {iLEDs = iLEDs |  2;}
      if (iAudioRechts > 925) {iLEDs = iLEDs |  1;}

      // Voor en achter LEDs aan.
      iLEDs_Voor_18   = 1;
      iLEDs_Achter_18 = 1;
      iLEDs_Voor_27   = 1;
      iLEDs_Achter_27 = 1;
    }

    // Bij een knipperlicht, rem of grootlicht alle LEDs resetten (Verwijderen van effeten.).
    if (iKnipperLinks || iMultiKnipperLinks || iKnipperRechts || iMultiKnipperRechts || iRemLicht || iGrootLicht) { iLEDs = 0; }

    // Knipperlichten.
    if (iKnipperLinks || iMultiKnipperLinks || iKnipperRechts || iMultiKnipperRechts) {

      // Knipperlicht Links.
      if (iKnipperLinks || iMultiKnipperLinks) {
        // Update de LEDs met de data van het huidige effect.
        iLEDs = iLEDs | aKnipperLinks[iKnipperSoort][iKnipperStap + 2];
        // Kort bedienen knipperlicht zorgt voor 3 x knipperen.
        if ((iMultiKnipperTel > 2) && (iMultiKnipperTel < 41)) {
          iMultiKnipperLinks = 1;
        } else {
          iMultiKnipperLinks = 0;
        }
        // Zet meerdere keren knipper van ander zijde uit.
        iMultiKnipperRechts = 0;
      }

      // Knipperlichten Rechts.
      if (iKnipperRechts || iMultiKnipperRechts) {
        // Update de LEDs met de data van het huidige effect.
        iLEDs = iLEDs | aKnipperRechts[iKnipperSoort][iKnipperStap + 1];
        // Kort bedienen knipperlicht zorgt voor 3 x knipperen.
        if ((iMultiKnipperTel > 2) && (iMultiKnipperTel < 41)) {
          iMultiKnipperRechts = 1;
        } else {
          iMultiKnipperRechts = 0;
        }
        // Zet meerdere keren knipper van ander zijde uit.
        iMultiKnipperLinks = 0;
      }

      // Controleer voor volgende stap (via linkerknipperlicht array).
      if (millis() > (iKnipperTijd + aKnipperLinks[iKnipperSoort][0])) {
        iKnipperStap++;
        iKnipperTijd = millis();
        iMultiKnipperTel++;
      }

      // Update de normale lampen met de data van het huidige effect.
      iKnipperLamp_Links  = iLEDs & 14336;
      iKnipperLamp_Rechts = iLEDs & 7;
      
      // Controleer of laatste stap van het effect is bereikt.
      if (iKnipperStap > aKnipperLinks[iKnipperSoort][1] - 1) { iKnipperStap = 0; }

    } else {
      // Geen knipperlichten.
      iKnipperStap        = 0;
      iMultiKnipperTel    = 0;
      iKnipperLamp_Links  = 0;
      iKnipperLamp_Rechts = 0;
    }

    // Dagrij verlichting
    if (iKeuze == 1) {
      iLEDs = iLEDs | 1032;
      iLEDs_Voor_18   = 1;
      iLEDs_Achter_18 = 1;
    }

    // Rem Aan/Uit
    if (iRemLicht) {
      // Update de LEDs met de data van het huidige effect.
      iLEDs = iLEDs | aRem[iRemSoort][iRemStap + 2];
      // Controleer voor volgende stap.
      if (millis() > (iRemTijd + aRem[iRemSoort][0])) {
        iRemStap++;
        iRemTijd = millis();
      }
      // Controleer of laatste stap van array is bereikt.
      if (iRemStap > aRem[iRemSoort][1] - 1) { iRemStap = aRem[iRemSoort][1] - 1; }
      iLEDs_Achter_18 = 1;
      iLEDs_Achter_27 = 1;
      if (iGrootLicht != 1) {iLEDs_Voor_27 = 0;}
      if ((iGrootLicht != 1) && (iKeuze != 1)) {iLEDs_Voor_18 = 0;}
    } else {
      iRemStap = 0;
    }

    // Grootlicht Aan/Uit
    if (iGrootLicht) {
      iLEDs = iLEDs | 2040;
      iLEDs_Voor_18 = 1;
      iLEDs_Voor_27 = 1;
      if (iRemLicht != 1) {iLEDs_Achter_27 = 0;}
      if ((iRemLicht != 1) && (iKeuze != 1)) {iLEDs_Achter_18 = 0;}
    }

    // Verwerk LED-uitgangen naar status string voor OLED-scherm.
    iLEDs_StatusPositie = 0;
    iLEDs_StatusVoor    = iLEDs;
    iLEDs_StatusAchter  = iLEDs;
    
    // LEDs voor actief of niet actief.
    if (iLEDs_Voor_18 != 1) { iLEDs_StatusVoor = iLEDs_StatusVoor & 15351; }
    if (iLEDs_Voor_27 != 1) { iLEDs_StatusVoor = iLEDs_StatusVoor & 15375; }
    
    // LEDs achter actief of niet actief.
    if (iLEDs_Achter_18 != 1) { iLEDs_StatusAchter = iLEDs_StatusAchter & 15351; }
    if (iLEDs_Achter_27 != 1) { iLEDs_StatusAchter = iLEDs_StatusAchter & 15375; } 

    // LED Status naar string voor en achter.
    for (iTel = 13; iTel >= 0; iTel--) {
      if (iLEDs_StatusVoor & aBin[iTel]) {
        sLEDs_StatusVoor[iLEDs_StatusPositie]   = '#';
      } else {
        sLEDs_StatusVoor[iLEDs_StatusPositie]   = '_';
      }
      if (iLEDs_StatusAchter & aBin[iTel]) {
        sLEDs_StatusAchter[iLEDs_StatusPositie]   = '#';
      } else {
        sLEDs_StatusAchter[iLEDs_StatusPositie]   = '_';
      }
      iLEDs_StatusPositie++;
    }

    // Verwerk menu regels voor OLED scherm.
    strncpy(sScherm_Regel_1, aScherm_Menu[iKeuzeScherm  + 0], 18);
    strncpy(sScherm_Regel_2, aScherm_Menu[iKeuzeScherm  + 1], 18);
    strncpy(sScherm_Regel_3, aScherm_Menu[iKeuzeScherm  + 2], 18);

    // Update het OLED-Scherm bij wijzigingen.
    if ((iKeuzeScherm_Vorige != iKeuzeScherm) || (iLEDs_StatusVoor_Vorige != iLEDs_StatusVoor) || (iLEDs_StatusAchter_Vorige != iLEDs_StatusAchter) || (iIngangen_Vorige != iIngangen)) {
      
      oled.clearScr();
      oled.print(sLEDs_StatusVoor, 22, 0);
      oled.print(sScherm_Regel_1, 5, 15);
      oled.print(sScherm_Regel_2, 5, 25);
      oled.print(sScherm_Regel_3, 5, 35);
      oled.print(sLEDs_StatusAchter, 22, 45);
      oled.rectangle(0, 23, 128, 10, 0, 1, false);

      if (iKnipperLinks) {
        oled.print("L", 0, 0);
      }
      if (iKnipperRechts) {
        oled.print("R", 118, 0);
      }
      if (iRemLicht) {
        oled.print("R", 0, 55);
      }
      if (iGrootLicht) {
        oled.print("G", 118, 55);
      }
      // Zet de geselecteerde EffectSoort het scherm.
      if ((iKeuzeScherm + -1) == iKeuze) { oled.print("=", 118, 15); }
      if ((iKeuzeScherm +  0) == iKeuze) { oled.print("=", 118, 25); }
      if ((iKeuzeScherm +  1) == iKeuze) { oled.print("=", 118, 35); }

      // Zet de geselecteerde KnipperSoort het scherm.
      if (((iKeuzeScherm + -1) == 18) && (iKnipperSoort == 0)) { oled.print("+", 118, 15); }
      if (((iKeuzeScherm + -1) == 19) && (iKnipperSoort == 1)) { oled.print("+", 118, 15); }
      if (((iKeuzeScherm + -1) == 20) && (iKnipperSoort == 2)) { oled.print("+", 118, 15); }
      if (((iKeuzeScherm +  0) == 18) && (iKnipperSoort == 0)) { oled.print("+", 118, 25); }
      if (((iKeuzeScherm +  0) == 19) && (iKnipperSoort == 1)) { oled.print("+", 118, 25); }
      if (((iKeuzeScherm +  0) == 20) && (iKnipperSoort == 2)) { oled.print("+", 118, 25); }
      if (((iKeuzeScherm +  1) == 18) && (iKnipperSoort == 0)) { oled.print("+", 118, 35); }
      if (((iKeuzeScherm +  1) == 19) && (iKnipperSoort == 1)) { oled.print("+", 118, 35); }
      if (((iKeuzeScherm +  1) == 20) && (iKnipperSoort == 2)) { oled.print("+", 118, 35); }

      // Zet de geselecteerde RemSoort het scherm.
      if (((iKeuzeScherm + -1) == 21) && (iRemSoort == 0)) { oled.print("+", 118, 15); }
      if (((iKeuzeScherm + -1) == 22) && (iRemSoort == 1)) { oled.print("+", 118, 15); }
      if (((iKeuzeScherm +  0) == 21) && (iRemSoort == 0)) { oled.print("+", 118, 25); }
      if (((iKeuzeScherm +  0) == 22) && (iRemSoort == 1)) { oled.print("+", 118, 25); }
      if (((iKeuzeScherm +  1) == 21) && (iRemSoort == 0)) { oled.print("+", 118, 35); }
      if (((iKeuzeScherm +  1) == 22) && (iRemSoort == 1)) { oled.print("+", 118, 35); }

      // Update het OLED scherm.
      oled.inflate();

      // Reset update.
      iLEDs_StatusVoor_Vorige   = iLEDs_StatusVoor;
      iLEDs_StatusAchter_Vorige = iLEDs_StatusAchter;
      iIngangen_Vorige          = iIngangen;
      iKeuzeScherm_Vorige       = iKeuzeScherm;

      // Bij een wijziging van de LEDs of OLED-scherm LED op de PCB ook wisselen.
       digitalWrite(LED_PCB, !digitalRead(LED_PCB));
    }

    // Bij een druk op keuzeschakelaar schermkeuze overnemen.
    if (iKeuzeSchakelaar == 0) {
      if ((iKeuzeScherm >= 0) && (iKeuzeScherm < 18)) { iKeuze = iKeuzeScherm; } // Effecten selectie
      if (iKeuzeScherm == 18) { iKnipperSoort = 0;} // Knipprlicht standaard.
      if (iKeuzeScherm == 19) { iKnipperSoort = 1;} // Knipprlicht 1 x loop.
      if (iKeuzeScherm == 20) { iKnipperSoort = 2;} // Knipprlicht 2 x loop.
      if (iKeuzeScherm == 21) { iRemSoort     = 0;} // Remlicht standaard.
      if (iKeuzeScherm == 22) { iRemSoort     = 1;} // Remlicht met effect.
    }

    // Verwerk de LED statussen
    if (iLEDs_Voor_18)   { digitalWrite(VOOR_18, 1);   } else { digitalWrite(VOOR_18, 0); }
    if (iLEDs_Voor_27)   { digitalWrite(VOOR_27, 1);   } else { digitalWrite(VOOR_27, 0); }
    if (iLEDs_Achter_18) { digitalWrite(ACHTER_18, 1); } else { digitalWrite(ACHTER_18, 0); }
    if (iLEDs_Achter_27) { digitalWrite(ACHTER_27, 1); } else { digitalWrite(ACHTER_27, 0); }
    if (iLEDs & 1)       { digitalWrite(LED_1, 1);     } else { digitalWrite(LED_1, 0); }
    if (iLEDs & 2)       { digitalWrite(LED_2, 1);     } else { digitalWrite(LED_2, 0); }
    if (iLEDs & 4)       { digitalWrite(LED_3, 1);     } else { digitalWrite(LED_3, 0); }
    if (iLEDs & 8)       { digitalWrite(LED_4, 1);     } else { digitalWrite(LED_4, 0); }
    if (iLEDs & 16)      { digitalWrite(LED_5, 1);     } else { digitalWrite(LED_5, 0); }
    if (iLEDs & 32)      { digitalWrite(LED_6, 1);     } else { digitalWrite(LED_6, 0); }
    if (iLEDs & 64)      { digitalWrite(LED_7, 1);     } else { digitalWrite(LED_7, 0); }
    if (iLEDs & 128)     { digitalWrite(LED_8, 1);     } else { digitalWrite(LED_8, 0); }
    if (iLEDs & 256)     { digitalWrite(LED_9, 1);     } else { digitalWrite(LED_9, 0); }
    if (iLEDs & 512)     { digitalWrite(LED_10, 1);    } else { digitalWrite(LED_10, 0); }
    if (iLEDs & 1024)    { digitalWrite(LED_11, 1);    } else { digitalWrite(LED_11, 0); }
    if (iLEDs & 2048)    { digitalWrite(LED_12, 1);    } else { digitalWrite(LED_12, 0); }
    if (iLEDs & 4096)    { digitalWrite(LED_13, 1);    } else { digitalWrite(LED_13, 0); }
    if (iLEDs & 8192)    { digitalWrite(LED_14, 1);    } else { digitalWrite(LED_14, 0); }

    // Verwerk de normale knipper lampen status.
    if (iKnipperLamp_Links)  { digitalWrite(KNIPPER_LINKS, 1);  } else { digitalWrite(KNIPPER_LINKS, 0); }
    if (iKnipperLamp_Rechts) { digitalWrite(KNIPPER_RECHTS, 1); } else { digitalWrite(KNIPPER_RECHTS, 0); }

    // Reset de LED statussen.
    iLEDs           = 0;
    iLEDs_Voor_18   = 0;
    iLEDs_Voor_27   = 0;
    iLEDs_Achter_18 = 0;
    iLEDs_Achter_27 = 0;

    // Wachttijd loop
    delay(1);
  }
}