#include <LiquidCrystal.h> 
#include <EEPROM.h>
#include<Wire.h>
LiquidCrystal lcd(4, 2, 3, 7, 5, 6);
int backlightpin = 9;
int ledrightpin = 13;
int ledleftpin = 8;
int leftpin = 10;
int rightpin = 11;
int breakreleasepin = 12;
int frontpot = A1;
int buttonpin = A2;
int potmeterpin = A3;

int memorychannel = 1;
long autodegree = 0;
int od = 0;
unsigned long lcdmillis;
int oldledstate = 0;
int ledstate = 0;
long rotorstartdegree = 0; 
long rotorenddegree = 450;
long breakreleasedelay = 500;
long potmeterzero = 0;
int potmetermax = 511;
int backlightvalue = 255;
int degreeeepromstart = 800;
int settingscount = 11;
int slow = 0;
unsigned long breakendmillis;
int breakactive = 0;
int breakholddelay = 10000;
int left = 0;
int right = 0;
float potmeterdegree = 0;
int menuoption = 1;
int buttondelay = 0;
int button = -1;
int memorycount = 97;
int y[] = {255, 254, 253, 251, 247, 239, 223, 191, 127};
int lednr[] = {8, 37, 38, 39, 40, 36, 35, 34, 33, 29, 30, 31, 32, 28 ,27, 26, 25, 20, 21, 22, 23, 24, 19 ,18 ,17, 16, 15, 14, 13, 9 ,10, 11, 12, 4, 3, 2, 1, 5 ,6 ,7, 8};
int chooseletter = 0;
char storeletter = 32;
int setupmenuval = 0;
int incomingByte = 0;
int command_buffer[40];
int autoturnselect = 0;
int pccontrol = 0;
int startupdemo = 0;
int softwarecount = 1;
int wintest = 0;


byte degreesign[8] = {
  B01100,
  B10010,
  B10010,
  B01100,
  B00000,
  B00000,
  B00000,
  B00000
};

byte arrowdown[8] = {
  B00000,
  B01110,
  B01110,
  B01110,
  B01110,
  B11111,
  B01110,
  B00100
};

void writeeeprombreakreleasedelay() {
  int eepromhigh =  breakreleasedelay / 100;
  int eepromlow = breakreleasedelay - (eepromhigh *100);
  long eepromadres = (2);
  EEPROM.write(eepromadres, eepromlow);
  EEPROM.write(eepromadres + 1, eepromhigh);
}

void writeeeprompotmeterzero() {
  int eepromhigh = potmeterzero / 100;
  int eepromlow = potmeterzero - (eepromhigh *100);
  long eepromadres = (4);
  EEPROM.write(eepromadres, eepromlow);
  EEPROM.write(eepromadres + 1, eepromhigh);
  
}

void writeeeprompotmetermax() {
  int eepromhigh =  potmetermax / 100;
  int eepromlow = potmetermax - (eepromhigh *100);
  long eepromadres = (6);
  EEPROM.write(eepromadres, eepromlow);
  EEPROM.write(eepromadres + 1, eepromhigh);
  
}

void writeeeprombacklightvalue() {
  int eeprom = backlightvalue;
  long eepromadres = (8);
  EEPROM.write(eepromadres, eeprom);
}

void writeeepromrotorenddegree() {
  int eepromhigh =  rotorenddegree / 100;
  int eepromlow = rotorenddegree - (eepromhigh *100);
  long eepromadres = (9);
  EEPROM.write(eepromadres, eepromlow);
  EEPROM.write(eepromadres + 1, eepromhigh);
  
}

void writeeepromrotorstartdegree() {
  long eepromrotorstartdegree = rotorstartdegree + 360;
  long eepromhigh =  eepromrotorstartdegree / 100;
  long eepromlow = eepromrotorstartdegree - (eepromhigh *100);
  long eepromadres = (11);
  EEPROM.write(eepromadres, eepromlow);
  EEPROM.write(eepromadres + 1, eepromhigh);
  
}

void readeepromsettings() {
  softwarecount = EEPROM.read(1020);
  wintest = EEPROM.read(1021);
  breakreleasedelay = (EEPROM.read(2) + (EEPROM.read(3) * 100));
  potmeterzero = (EEPROM.read(4) + (EEPROM.read(5) * 100));
  potmetermax = (EEPROM.read(6) + (EEPROM.read(7) * 100));
  backlightvalue = EEPROM.read(8);
  analogWrite(backlightpin, backlightvalue);
  rotorenddegree = (EEPROM.read(9) + (EEPROM.read(10) * 100));
  rotorstartdegree = (EEPROM.read(11) + (EEPROM.read(12) * 100) - 360);
}

void setledrose( long degree) {
if (degree < 0) degree = degree + 360;
if (degree > 360) degree = degree -360;
if (degree > 720) degree = degree -360;
long led = (degree * 10) / 88;
int outputpin = lednr[led];
int iicaddr = 0;
int count = 0;
  if (outputpin < 9) {
    iicaddr = 32;
    count = 0;
  }
  if (outputpin > 8 && outputpin < 17) {
    iicaddr = 33;
    count = 8;
  }
  if (outputpin > 16 && outputpin < 25) {
    iicaddr = 34;
    count = 16;
  }
  
  if (outputpin > 24 && outputpin < 33 ){
    iicaddr = 35;
    count = 24;
  }
  
  if (outputpin > 32 && outputpin < 41) {
    iicaddr = 36;
    count = 32;
  }
  iicsend(outputpin, iicaddr, count);
}

void iicsend(int ledadres, int iicaddr, int count){
    Wire.beginTransmission(iicaddr);
    Wire.write(y[ledadres - count]);
    Wire.endTransmission();

  if (ledadres > 8) {
    Wire.beginTransmission(32);
    Wire.write(255);
    Wire.endTransmission();
  }
  if (ledadres < 9 || ledadres > 16) {
    Wire.beginTransmission(33);
    Wire.write(255);
    Wire.endTransmission();
  }
    if (ledadres < 17 || ledadres > 24) {
    Wire.beginTransmission(34);
    Wire.write(255);
    Wire.endTransmission();
   }
  if (ledadres < 25 || ledadres > 32) {
    Wire.beginTransmission(35);
    Wire.write(255);
    Wire.endTransmission();
  }
  if (ledadres < 33) {
    Wire.beginTransmission(36);
    Wire.write(255); 
    Wire.endTransmission();
  } 
}

void readpotmeter() {
  long potmetervaluesum = 0;
  for (int count = 0; count < 20; count++) {
    int potmetertemp = (analogRead(potmeterpin) /2);
    potmetervaluesum = potmetervaluesum + potmetertemp;
  }
  int potmetervalue = potmetervaluesum / 20;
  potmetervaluesum = 0;
  if (potmetervalue < potmeterzero) potmetervalue = potmeterzero;
  if (potmetervalue > potmetermax) potmetervalue = potmetermax;
  float potmeterrange = (potmetermax - potmeterzero);
  potmeterdegree = ((potmetervalue - potmeterzero) / (potmeterrange / (rotorenddegree - rotorstartdegree)));
  potmeterdegree = potmeterdegree + rotorstartdegree;
  if (autoturnselect == 1) setledrose(autodegree);
  setledrose(potmeterdegree);
}

void readbuttons(){ 
  int pinread = analogRead(buttonpin);
  if (pinread > -1 && pinread < 30) {
    buttondelay ++; 
    if (buttondelay == 2) button = 1;
    else button = -1; 
  }
  if (pinread > 30 && pinread < 100) {
    button = 2;
    delay(200);
  }
  if (pinread > 500 && pinread < 750) {
    button = 3;
    delay(200);
  }
  if (pinread > 800 && pinread < 999) {
    buttondelay ++;
    if (buttondelay == 2) button = 4;
    else button = -1; 
  }
  if (pinread > 1000) { 
   buttondelay = 0; 
   button = -1; 
  }
}

void sellectmenu(){
  if (menuoption < 10) menu();
  if (menuoption == 11) setbacklight();
  if (menuoption == 12) setbreakrelease();
  if (menuoption == 13) software();
  if (menuoption == 21) setrotorstart();
  if (menuoption == 22) setrotorend();
  if (menuoption == 23) setmaxleft();
  if (menuoption == 24) setmaxright();
  if (menuoption == 30) demo();
  if (menuoption == 95) turnrotorto();
  if (menuoption == 96) storememoryname();
  if (menuoption == 97) recallmemorychannel();
  if (menuoption == 98) storememorychannel();
  if (menuoption == 99) deletememorychannel();  
}

void menu(){
  if (button == 1) {
    menuoption ++;
    button = -1;
  }
  if (menuoption == 6) menuoption = 1;
  if (menuoption == 1) heading();
  if (menuoption == 2) memory();
  if (menuoption == 3) settings();
  if (menuoption == 4) calibrate();
  if (menuoption == 5) startdemo();
}

void software() {
  lcd.setCursor(0, 0);
  lcd.print("    Software      ");
  lcd.setCursor(0, 1);
  if (softwarecount == 1) lcd.print("    default        "); 
  if (softwarecount == 2) lcd.print("    Wintest        ");
  if (softwarecount  < 1) softwarecount = 2;
  if (softwarecount  > 2) softwarecount = 1;
  if (button == 2) {
   softwarecount --;
   delay(100);
  }
  if (button == 3) {
    softwarecount ++;
    delay(100);
  }
  if (button == 4 && softwarecount == 1) {
    delay(300);
    wintest = 0; 
    EEPROM.write(1020, softwarecount);
    EEPROM.write(1021, wintest);
    asm volatile ("  jmp 0");
    menuoption = 1;
  }   
  if (button == 4 && softwarecount == 2) {
    delay(300);
    wintest = 1;
    EEPROM.write(1020, softwarecount);
    EEPROM.write(1021, wintest);
    asm volatile ("  jmp 0");
    menuoption = 1;  
  }
}

void calibrate(){
  lcd.setCursor(0, 0);
  lcd.print("    Calibrate       ");
  lcd.setCursor(0, 1);
  lcd.print("     start        ");
  if (button == 4) {
    menuoption = 21;
    button = -1;
  }
}

void settings() {
  lcd.setCursor(0, 0);
  lcd.print("    Settings     ");
  lcd.setCursor(0, 1);
  if (settingscount == 11) lcd.print("   backlight         "); 
  if (settingscount == 12) lcd.print(" breake release      ");
  if (settingscount == 13) lcd.print("    software         ");
  if (settingscount == 10) settingscount = 13;
  if (settingscount == 14) settingscount = 11;
  if (button == 2) {
   settingscount --;
   delay(100);
  }
  if (button == 3) {
    settingscount ++;
    delay(100);
  }
  if (button == 4) {
    menuoption = settingscount;
    button = -1;
  }
}

void memory() {
  lcd.setCursor(0, 0);
  lcd.print("     Memory     ");
  lcd.setCursor(0, 1);
  if (memorycount == 97) lcd.print("    recall        "); 
  if (memorycount == 98) lcd.print("     store        ");
  if (memorycount == 99) lcd.print("     delete       ");
  if (memorycount == 96) memorycount = 98;
  if (memorycount == 99) memorycount = 97;
  if (button == 2) {
   memorycount --;
   delay(100);
  }
  if (button == 3) {
    memorycount ++;
    delay(100);
  }
  if (button == 4) {
    menuoption = memorycount;
    button = -1;
  }
}

void recallmemorychannel() {
  lcd.setCursor(0, 0);
  lcd.print("    recall      ");
  lcd.setCursor(0, 1);
  lcd.print(memorychannel);
  lcd.print("=");
  for (int character = 0; character < 14; character ++) {
    char letter = EEPROM.read((memorychannel * 15) + character);
    if (letter < 32) letter = 32;
    lcd.print(letter);
  }
  lcd.print("          ");
  if (button == 1) {
    done();
  }
  
  if (button == 2) {
    memorychannel --;
    delay(100);
  }
  if (button == 3) {
    memorychannel ++;
    delay(100);
  }
  if (memorychannel < 1) memorychannel = 50;
  if (memorychannel > 50) memorychannel = 1;
  if (button == 4) {
    int eepromlow = EEPROM.read(memorychannel + 900);
    int eepromhigh = EEPROM.read(memorychannel + 960);
    autodegree = ((eepromhigh * 100) + eepromlow);
    lcd.setCursor(0, 0);
    for (int character = 0; character < 14; character ++) {
      char letter = EEPROM.read((memorychannel * 15) + character);
      if (letter < 32) letter = 32;
      lcd.print(letter);
    }
    menuoption = 95;
  }
}

void storememorychannel() {
  lcd.setCursor(0, 0);
  lcd.print("     store        ");
  lcd.setCursor(0, 1);
  lcd.print(memorychannel);
  lcd.print("=");
  for (int character = 0; character < 13; character ++) {
    char letter = EEPROM.read((memorychannel * 15) + character);
    if (letter < 32) letter = 32;
    lcd.print(letter);
  }
  lcd.print("          ");
  if (button == 1) done();
  if (button == 2) {
    memorychannel --;
    delay(100);
  }
  if (button == 3) {
    memorychannel ++;
    delay(100);
  }
  if (memorychannel < 1) memorychannel = 50;
  if (memorychannel > 50) memorychannel = 1;
  if (button == 4) {
    storeletter = EEPROM.read(memorychannel * 15);
    menuoption = 96;
  }
}

void deletememorychannel() {
  lcd.setCursor(0, 0);
  lcd.print("     delete       ");
  lcd.setCursor(0, 1);
  lcd.print(memorychannel);
  lcd.print("=");
  lcd.print("          ");
  if (button == 1) done();
  if (button == 2) {
    memorychannel --;
    delay(100);
  }
  if (button == 3) {
    memorychannel --;
    delay(100);
  }
  if (memorychannel < 1) memorychannel = 50;
  if (memorychannel > 50) memorychannel = 1;
  if (button == 4) ;
}

void storememoryname() {
  int arrow = 1;
  for (int character = 0; character < 14; character++) {
    lcd.setCursor(character, 0);
    if (character != chooseletter) {
      lcd.print(" ");
    lcd.setCursor(character, 1);
    char letter = EEPROM.read((memorychannel * 15) + character);
    if (letter < 32) letter = 32;
    lcd.print(letter);
    }
  }
  lcd.setCursor(chooseletter, 0);
  lcd.write(arrow);
  lcd.setCursor(0, 1);
  lcd.setCursor(chooseletter, 1);
  lcd.print(storeletter);

  if (button == 4) {
    EEPROM.write((memorychannel * 15) + chooseletter, storeletter);
    chooseletter ++;
    if (chooseletter > 13) chooseletter = 0;
    storeletter = EEPROM.read((memorychannel * 15) + chooseletter);
    if (storeletter < 32) storeletter = 32;
  }
  if (chooseletter > 13) chooseletter = 0;
  if (chooseletter < 0) chooseletter = 13;
  if (button == 2) {
    storeletter --;
  }
  if (button == 3) {
    storeletter ++;
  }
  if (storeletter == 0) storeletter = 32;
  if (storeletter < 32) storeletter = 122;
  if (storeletter > 122) storeletter = 32;
  if (storeletter == 47) storeletter = 32;
  if (storeletter == 33) storeletter = 48;
  if (storeletter == 58) storeletter = 65;
  if (storeletter == 64) storeletter = 57;
  if (storeletter == 91) storeletter = 97;
  if (storeletter == 96) storeletter = 90;
  if (button == 1) {
    writeeepromdegree(memorychannel);
    chooseletter = 0;
    done();
  }
}

void writeeepromdegree(int adress) {
  long rotordirection = potmeterdegree;
  if (rotordirection > 359) rotordirection = rotordirection - 360;
  if (rotordirection > 719) rotordirection = rotordirection - 360;
  int eepromhigh =  rotordirection / 100;
  int eepromlow = rotordirection - (eepromhigh *100);
  EEPROM.write(adress + 900, eepromlow);
  EEPROM.write(adress + 960, eepromhigh);
}

void turnrotorto() {
  autoturnselect = 1;
  int degree = 0;
  lcd.setCursor(0, 1);
  lcd.print("turning to ");
  lcd.print(autodegree);
  lcd.write(degree);
  lcd.print("          ");
  int rotordirection = potmeterdegree;
  if (rotordirection > 359) rotordirection = rotordirection - 360;
  if (rotordirection > 719) rotordirection = rotordirection - 360;  
  if (((autodegree + rotorstartdegree) < rotorstartdegree) || (autodegree > rotorenddegree)) {
    lcd.setCursor(0, 1);
    lcd.print("  out of range        ");
    delay (1000);
    done();
  }
  else if ((autodegree <= 90) && (rotordirection < autodegree + 180)) {
   if (autodegree + rotorstartdegree < rotordirection) turnlefton();
   if (autodegree + rotorstartdegree > rotordirection) turnrighton();
  }
  else if ((autodegree + 360) > rotorenddegree) {
   if (autodegree < rotordirection) turnlefton();
   if (autodegree > rotordirection) turnrighton();
  } 
  else if ((autodegree + 360) <= rotorenddegree) {
   if (autodegree < rotordirection - 360) turnlefton();
   if (autodegree > rotordirection - 360) turnrighton();
  }
  else  {
    turnlefton();
  }
  if (rotordirection == autodegree || rotordirection - 360 == autodegree) {
    autoturnselect = 0;
    turnleftoff();
    turnrightoff();
    done();
  }
  Serial.print(rotordirection);
  Serial.print("    ");
  Serial.println(autodegree);
}

void done(){
  lcd.setCursor(0, 0);
  lcd.print("     done        ");
  lcd.setCursor(0, 1);
  lcd.print("                 ");
  menuoption = 1;
  delay (500);
} 

void setrotorstart() {
  if (rotorstartdegree == -360) rotorstartdegree = 0;
  lcd.setCursor(0, 0);
  lcd.print("  Rotor start      "); 
  lcd.setCursor(0, 1);
  lcd.print("     ");
  lcd.print(rotorstartdegree);
  lcd.print("      ");
  if (button == 2) {
    rotorstartdegree = rotorstartdegree - 1;
    delay(50);
  }
  if (button == 3) {
    rotorstartdegree = rotorstartdegree + 1;
    delay(50);
  }
  if (rotorstartdegree < -360) rotorstartdegree = -360;
  if (rotorstartdegree == 360) rotorstartdegree = 360;
  if (button == 4) {
    writeeepromrotorstartdegree();
    menuoption = 22;
    button = -1;
  }
}

void setrotorend() {
  int degree = 0;
  lcd.setCursor(0, 0);
  lcd.print("   Rotor end    "); 
  lcd.setCursor(0, 1);
  lcd.print("     ");
  if (rotorenddegree < 10) lcd.print(" ");
  if (rotorenddegree < 100) lcd.print(" ");
  lcd.print(rotorenddegree);
  lcd.write(degree);
  lcd.print("    ");
  if (button == 2) {
    rotorenddegree = rotorenddegree - 1;
    delay(50);
  }
  if (button == 3) {
    rotorenddegree = rotorenddegree + 1;
    delay(50);
  }
  if (rotorenddegree < 0) rotorenddegree = 0;
  if (rotorenddegree > 1080) rotorenddegree = 1080;
  if (button == 4) {
    writeeepromrotorenddegree();
    menuoption = 23;
    button = -1;
  }
}

void setmaxleft() {
  lcd.setCursor(0, 0);
  lcd.print(" Turn max left   ");
  lcd.setCursor(0, 1);
  lcd.print("                 ");
  if (button == 2) turnlefton(); 
  if (button == 3) turnrighton();
  if (button == -1) {
    turnleftoff();
    turnrightoff();
  }
  potmeterzero = (analogRead(potmeterpin) /2);
  if (button == 4) {
    writeeeprompotmeterzero();
    menuoption = 24;
    button = -1;
  }
}

void setmaxright() {
  int degree = 0;
  lcd.setCursor(0, 0);
  lcd.print(" Turn max right   "); 
  lcd.setCursor(0, 1);
  lcd.print("                 ");
  if (button == 2) turnlefton(); 
  if (button == 3) turnrighton();
  if (button == -1) {
    turnleftoff();
    turnrightoff();
  }
  potmetermax = (analogRead(potmeterpin) /2);
  if (button == 4) {
    writeeeprompotmetermax();
    done();
    button = -1;
  }
}

void setbacklight() {
  lcd.setCursor(0, 0);
  lcd.print("   Backlight       "); 
  lcd.setCursor(0, 1);
  lcd.print("      ");
  float onepercent = 2.55;
  int lcdvalue = backlightvalue / onepercent;
  lcd.print(lcdvalue);
  lcd.print("%     ");
  if (button == 4) {
    writeeeprombacklightvalue();
    done();
  }
  if (button == 2) backlightvalue = backlightvalue - onepercent;
  if (button == 3) backlightvalue = backlightvalue + onepercent;
  if (backlightvalue < 0) backlightvalue = 0;
  if (backlightvalue > 255) backlightvalue = 255;
  analogWrite(backlightpin, backlightvalue);
}

void setbreakrelease() {
  lcd.setCursor(0, 0);
  lcd.print("  breakrelease    "); 
  lcd.setCursor(0, 1);
  lcd.print(" delay = ");
  lcd.print(breakreleasedelay);
  lcd.print("ms     ");
  if (button == 4) {
    writeeeprombreakreleasedelay();
    done();
  }
  if (button == 2) breakreleasedelay = breakreleasedelay - 10;
  if (button == 3) breakreleasedelay = breakreleasedelay + 10;
  if (breakreleasedelay < 0) breakreleasedelay = 0;
  if (breakreleasedelay > 5000) breakreleasedelay = 5000;
}

void lcdheading() {
  int degree = 0;
  int rotordirection;
  rotordirection = potmeterdegree;
  lcd.setCursor(13, 1);
  if (rotordirection > 360 + rotorstartdegree) {
    lcd.print("OD ");
    od = 1;
  }
  if (rotordirection <= 360 + rotorstartdegree) {
    lcd.print("   ");
    od = 0;
  }
  if (rotordirection > 359) rotordirection = rotordirection - 360;
  if (rotordirection > 719) rotordirection = rotordirection - 360;  
  lcd.setCursor(0, 0);
  lcd.print("Rotor direction  ");
  lcd.setCursor(0, 1);
  if (lcdmillis < millis()) { 
    lcd.print("      ");
    if (rotordirection < 9) lcd.print(" ");
    if (rotordirection < 99) lcd.print(" ");
    lcd.print(rotordirection);
    lcd.write(degree);
    lcd.print("     ");
    lcdmillis = millis() + 500;
  }
}

void turnrotor() {
  if (button == 2 && potmeterdegree > rotorstartdegree) turnlefton(); 
  if (button == 3 && potmeterdegree < rotorenddegree) turnrighton();
  if (potmeterdegree <= rotorstartdegree) turnleftoff();
  if (potmeterdegree >= (rotorenddegree -1)) turnrightoff();
  if (button == -1 && pccontrol == 0) {
    turnleftoff();
    turnrightoff();
  }
}

void turnlefton() {
  left = 1;
  if (right != 1) {
    if (breakactive == 0) breakrelease();
    breakendmillis = millis() + breakholddelay;
    if (breakactive == 1) {
      digitalWrite (ledleftpin, 1);
      digitalWrite (leftpin, 1);
    }
  }
}

void turnrighton() {
  right = 1;
  if (left != 1) {
    if (breakactive == 0) breakrelease();
    breakendmillis = millis() + breakholddelay;
    if (breakactive == 1) { 
      digitalWrite (ledrightpin, 1);
      digitalWrite (rightpin, 1);
    }
  }
}

void turnleftoff() {
  left = 0;
  digitalWrite (ledleftpin, 0);
  digitalWrite (leftpin, 0);
}

void turnrightoff() {
  right = 0;
  digitalWrite (ledrightpin, 0);
  digitalWrite (rightpin, 0);
}

void breakrelease() {
  digitalWrite (breakreleasepin, 1);
  delay(breakreleasedelay);
  breakactive = 1;
  unsigned long currentmillis = millis();
  breakendmillis = currentmillis + breakholddelay;
  while (currentmillis < breakendmillis) {
    if (left == 1) turnlefton();
    if (right == 1) turnrighton();
    currentmillis = millis();
    readpotmeter();
    readbuttons();
    sellectmenu();
  }
  digitalWrite (breakreleasepin, 0);
  breakactive = 0;
} 

void startdemo() {
  lcd.setCursor(0, 0);
  lcd.print("      Demo         "); 
  lcd.setCursor(0, 1);
  lcd.print("                   ");
  if (button == 4) menuoption = 30;
}

void demo() {
  lcd.setCursor(0, 0);
  lcd.print("rotor controller ");
  lcd.setCursor(0, 1);
  lcd.print(" Made by PE1BR    ");
  for (int led = 0; led < 360; led++){
    setledrose(led);
    delay(3);
    readbuttons();
    if (button == 4) {
      done();
      button = -1;
    }
    if (led == 1){
      digitalWrite (ledleftpin, ledstate);
      if (oldledstate == 0) ledstate = 1;
      if (oldledstate == 1) ledstate = 0;
      digitalWrite (ledrightpin, ledstate);
      oldledstate = ledstate;
    }
  }
}

void heading() {
  lcdheading();
  turnrotor();
  check_serial();
}

void setup() {
  Serial.setTimeout(10);
  pinMode (ledleftpin, OUTPUT);
  pinMode (ledrightpin, OUTPUT);
  pinMode (backlightpin, OUTPUT);
  pinMode (leftpin, OUTPUT);
  pinMode (rightpin, OUTPUT);
  pinMode (breakreleasepin, OUTPUT);
  analogWrite(backlightpin, backlightvalue);
  readeepromsettings();
  if (wintest == 0) Serial.begin(9600);
  if (wintest == 1) Serial.begin(4800);
  lcd.begin(16, 2);
  lcd.createChar(0, degreesign);
  lcd.createChar(1, arrowdown);
  Wire.begin();
  Wire.beginTransmission(32);     
  Wire.write(255);
  Wire.endTransmission();
  Wire.beginTransmission(33);
  Wire.write(255);
  Wire.endTransmission();
  Wire.beginTransmission(34);
  Wire.write(255);
  Wire.endTransmission();
  Wire.beginTransmission(35);
  Wire.write(255);
  Wire.endTransmission();
  Wire.beginTransmission(36);
  Wire.write(255);
  Wire.endTransmission();
  lcdmillis = millis() + 100;
  if (analogRead(buttonpin) > 800 && analogRead(buttonpin) < 999) startupdemo = 1;
}
void loop() {
  if (startupdemo == 1) menuoption = 30;
  readpotmeter();
  readbuttons();
  sellectmenu();
  check_serial();
}

void check_serial(){
  if (Serial.available() > 0) {
    String incoming_serial;
    incoming_serial=Serial.readString();
    if (incoming_serial.startsWith("L")) { // L - manual left (CCW) rotation
        pccontrol = 1;
        turnlefton();
    }
    if (incoming_serial.startsWith("R")) { // R - manual right (CW) rotation
        pccontrol = 1;
        turnrighton();
    }
    if (incoming_serial.startsWith("A")) { // A - stop rotation
        turnleftoff();
        turnrightoff();
        pccontrol = 0;
    }
    if (incoming_serial.startsWith("S")) { // S - cancel all
        turnleftoff();
        turnrightoff();
        pccontrol = 0;
    }
    if (incoming_serial.startsWith("C")) {       // C - return current azimuth
        long serialsenddegree = potmeterdegree;
        if (wintest == 0) Serial.print("AZ=");
        if (wintest == 1) Serial.print("0");
        if (potmeterdegree < 100) Serial.print("0");
        if (potmeterdegree < 10) Serial.print("0");
        Serial.print(serialsenddegree);
        if (wintest == 0) Serial.println(",0");
        if (wintest == 1) Serial.println(""); 
    }
    if (incoming_serial.startsWith("M")) { // M - turn to *** degree
        pccontrol = 1;
        int index = 0;
        int firstnumber = (incoming_serial.indexOf('M') +1); //first character posistion
        int lastnumber = (incoming_serial.indexOf('M'), +4); //last character position
        String autodegreestring = (incoming_serial.substring(firstnumber,lastnumber));
        char tarray[4];
        autodegreestring.toCharArray(tarray, sizeof(tarray));
        autodegree = atoi(tarray); 
        Serial.println(autodegree);
        menuoption = 95;
        pccontrol = 0;
    }
    
    if (incoming_serial.startsWith("W")) { // W - turn to *** degree
        pccontrol = 1;
        int index = 0;
        int firstnumber = (incoming_serial.indexOf('W') +1); //first character posistion
        int lastnumber = (incoming_serial.indexOf('W'), +4); //last character position
        String autodegreestring = (incoming_serial.substring(firstnumber,lastnumber));
        char tarray[4];
        autodegreestring.toCharArray(tarray, sizeof(tarray));
        autodegree = atoi(tarray); 
        Serial.println(autodegree);
        menuoption = 95;
        pccontrol = 0;
    }
  }
}