// Uebersetzung:          1 : 21
//               168 Zaehne : 8 Zaehne
//                 360 Grad : 7560 Grad
//
//
//               1 Minute = 7560 Grad / 60 Minuten = 126 Grad
//               1 Stunde = 7560 Grad / 12 Stunden = 630 Grad
//
//__________________________________________________________________________________________________________________________________________
// Deklaration der Variablen mit Globalem Geltungsbereich.
bool i1, i2, i3, min_b, h_b, w_min, w_h;
byte min, h;


//__________________________________________________________________________________________________________________________________________
// Zeichnet vertikale Linien der Nummern auf das Display.
void v_line(byte left, bool Y)
{
byte X;
        switch(left)
        {
          case 0:
          X = 2;
          break;
          case 1:
          X = 20;
          break;
          case 2:
          X = 26;
          break;
          case 3:
          X = 44;
          break;
          case 4:
          X = 56;
          break;
          case 5:
          X = 74;
          break;
          case 6:
          X = 80;
          break;
          case 7:
          X = 98;
          break;
        }
  if (Y)
  {
    LineOut((X - 1), 14, (X - 1), 30);
    LineOut(X, 13, X, 31);
    LineOut((X + 1), 14, (X + 1), 30);
  }
  else
  {
    LineOut((X - 1), 34, (X - 1), 50);
    LineOut(X, 33, X, 51);
    LineOut((X + 1), 34, (X + 1), 50);
  }
}


//__________________________________________________________________________________________________________________________________________
// Zeichnet horizontale Linien der Nummern auf das Display.
void h_line(byte left, bool up, bool middle)
{
byte X;
        switch(left)
        {
          case 0:
          X = 3;
          break;
          case 1:
          X = 27;
          break;
          case 2:
          X = 57;
          break;
          case 3:
          X = 81;
          break;
        }
  if (up)
  {
    LineOut((X + 1), 53, (X + 15), 53);
    LineOut(X, 52, (X + 16), 52);
    LineOut((X + 1), 51, (X + 15), 51);
  }
  else
  {
    if (middle)
    {
      LineOut((X + 1), 33, (X + 15), 33);
      LineOut(X, 32, (X + 16), 32);
      LineOut((X + 1), 31, (X + 15), 31);
    }
    else
    {
      LineOut((X + 1), 13, (X + 15), 13);
      LineOut(X, 12, (X + 16), 12);
      LineOut((X + 1), 11, (X + 15), 11);
    }
  }
}


//__________________________________________________________________________________________________________________________________________
// Setzt Nummern aus horizontalen und vertikalen Linien zusammen. "left"(1-4) gibt dabei die stelle auf dem Display an.
void draw_number(byte n, byte left)
{
        switch(n)
        {
          case 0:
            v_line(((left * 2) - 1), true);
            v_line(((left * 2) - 2), true);
            v_line(((left * 2) - 1), false);
            v_line(((left * 2) - 2), false);
            h_line((left - 1), true, false);
            h_line((left - 1), false, false);
          break;
          case 1:
            v_line(((left * 2) - 1), true);
            v_line(((left * 2) - 1), false);
          break;
          case 2:
            h_line((left - 1), true, false);
            v_line(((left * 2) - 2), true);
            h_line((left - 1), false, true);
            v_line(((left * 2) - 1), false);
            h_line((left - 1), false, false);
          break;
          case 3:
            h_line((left - 1), true, false);
            v_line(((left * 2) - 1), true);
            h_line((left - 1), false, true);
            v_line(((left * 2) - 1), false);
            h_line((left - 1), false, false);
          break;
          case 4:
            v_line(((left * 2) - 1), true);
            v_line(((left * 2) - 2), false);
            v_line(((left * 2) - 1), false);
            h_line((left - 1), false, true);
          break;
          case 5:
            h_line((left - 1), true, false);
            v_line(((left * 2) - 1), true);
            h_line((left - 1), false, true);
            v_line(((left * 2) - 2), false);
            h_line((left - 1), false, false);
          break;
          case 6:
            v_line(((left * 2) - 2), true);
            v_line(((left * 2) - 1), true);
            v_line(((left * 2) - 2), false);
            h_line((left - 1), true, false);
            h_line((left - 1), false, true);
            h_line((left - 1), false, false);
          break;
          case 7:
            h_line((left - 1), true, false);
            v_line(((left * 2) - 1), true);
            v_line(((left * 2) - 1), false);
          break;
          case 8:
            v_line(((left * 2) - 1), true);
            v_line(((left * 2) - 2), true);
            v_line(((left * 2) - 1), false);
            v_line(((left * 2) - 2), false);
            h_line((left - 1), true, false);
            h_line((left - 1), false, true);
            h_line((left - 1), false, false);
          break;
          case 9:
            v_line(((left * 2) - 1), true);
            v_line(((left * 2) - 2), false);
            v_line(((left * 2) - 1), false);
            h_line((left - 1), true, false);
            h_line((left - 1), false, true);
            h_line((left - 1), false, false);
          break;
        }
}


//__________________________________________________________________________________________________________________________________________
// Legt fest ob die zahl ein oder zweistellig ist. Ist die Anzahl der Minute kleiner als 10, wird eine "0" vorrangestellt.
void number(byte n, bool htmp)
{
byte ntmp;
bool h;
  if(htmp && n < 10)
  {
    draw_number(0, 3);
  }
h = htmp;
  if(n < 10 && n > -1)
  {
      ntmp = n;
  }
  else
  {
    if(n < 20 && n > 9)
    {
       ntmp = n - 10;
         if(h)
         {
           draw_number(1, 3);
         }
         else
         {
           draw_number(1, 1);
         }
    }
    else
    {
      if(n < 30 && n > 19)
      {
      ntmp = n - 20;
        if(h)
        {
          draw_number(2, 3);
        }
        else
        {
          draw_number(2, 1);
        }
      }
      else
      {
        if(n < 40 && n > 29)
        {
        ntmp = n - 30;
          if(h)
          {
            draw_number(3, 3);
          }
          else
          {
            draw_number(3, 1);
          }
        }
        else
        {
          if(n < 50 && n > 39)
          {
          ntmp = n - 40;
            if(h)
            {
              draw_number(4, 3);
            }
            else
            {
              draw_number(4, 1);
            }
          }
          else
          {
            if(n < 60 && n > 49)
            {
            ntmp = n - 50;
              if(h)
              {
                draw_number(5, 3);
              }
              else
              {
                draw_number(5, 1);
              }
            }
          }
        }
      }
    }
  }
    if(h)
    {
    draw_number(ntmp, 4);
    }
    else
    {
    draw_number(ntmp, 2);
    }
}


//__________________________________________________________________________________________________________________________________________
// Ausgabeflaeche(Display) aktuallisieren
void show()
{
byte x,y1,y2;
x = 50;
y1 = 41;
y2 = 22;
ClearScreen();
number(h, false);
number(min, true);
CircleOut(x,y1,1);
CircleOut(x,y1,2);
CircleOut(x,y2,1);
CircleOut(x,y2,2);
}


//__________________________________________________________________________________________________________________________________________
// Setzt Variablen der NXT Tasten auf "falsch".
sub btn_reset()
{
i1 = false;
i2 = false;
i3 = false;
}


//__________________________________________________________________________________________________________________________________________
// Zeigt beim stellen an, ob Stunde oder Minute gerade bearbeitet werden.
void show_set(bool h)
{
show();
TextOut(5,LCD_LINE8,"<<   ENTER   >>");
  if(h)
  {
    TextOut(13,LCD_LINE1,"HOUR");
  }
  else
  {
    TextOut(60,LCD_LINE1,"MINUTE");
  }
}


//__________________________________________________________________________________________________________________________________________
// Eingabe der Uhrzeit, addiert 1 Minute.
void min_plus()
{
  if(min < 59)
  {
    min = min + 1;
  }
  else
  {
    if(min == 59 || min > 59)
    {
      min = 0;
    }
  }
}


//__________________________________________________________________________________________________________________________________________
// Eingabe der Uhrzeit, subtrahiert 1 Minute.
void min_minus()
{
  if(min > 0)
  {
    min = min - 1;
  }
  else
  {
    if(min == 0 || min < 0)
    {
      min = 59;
    }
  }
}


//__________________________________________________________________________________________________________________________________________
// Eingabe der Uhrzeit, addiert 1 Stunde.
void h_plus()
{
  if(h < 23)
  {
    h = h + 1;
  }
  else
  {
    if(h == 23 || h > 23)
    {
      h = 0;
    }
  }
}


//__________________________________________________________________________________________________________________________________________
// Eingabe der Uhrzeit, subtrahiert 1 Stunde.
void h_minus()
{
  if(h > 0)
  {
    h = h - 1;
  }
  else
  {
    if(h == 0 || h < 0)
    {
      h = 23;
    }
  }
}


//__________________________________________________________________________________________________________________________________________
// Dreht den Minutenzeiger um 1 Minute nach vorn.
task min_mech_plus()
{
  RotateMotor(OUT_B,50,126);
}


//__________________________________________________________________________________________________________________________________________
// Dreht den Stundenzeiger um 1 Stunde nach vorn.
task h_mech_plus()
{
  RotateMotor(OUT_C,-50,630);
}


//__________________________________________________________________________________________________________________________________________
// Dreht den Minutenzeiger von der "6 Uhr" Grundstellung, zur aktuell eingegebenen Minute.
// Zeitgleich wird der Stundenzeiger vom zugehoerigen task gestellt.
task set_min()
{
byte mintmp;
mintmp = 0;
    if(min <> 30)
    {
      if(min > 30)
      {
        mintmp = min - 30;
        RotateMotor(OUT_B,60,(126 * mintmp));
      }
      else
      {
        mintmp = 30 - min;
        RotateMotor(OUT_B,-60,(126 * mintmp));
      }
   }
w_min = true;
}


//__________________________________________________________________________________________________________________________________________
// Dreht den Stundenzeiger von der "6 Uhr" Grundstellung, zur aktuell eingegebenen Stunde.
// Zeitgleich wird der Minutenzeiger vom zugehoerigen task gestellt.
task set_h()
{
byte htmp, htmp1;
htmp = 0;
htmp1 = 0;
  if(h > 12)
  {
    htmp1 = h - 12;
  }
  else
  {
    htmp1 = h;
  }
    if(htmp1 <> 6)
    {
      if(htmp1 > 6)
      {
        htmp = htmp1 - 6;
        RotateMotor(OUT_C,-60,(630 * htmp));
      }
      else
      {
        htmp = 6 - htmp1;
        RotateMotor(OUT_C,60,(630 * htmp));
      }
   }
w_h = true;
}


//__________________________________________________________________________________________________________________________________________
// Der Programmstart enthaelt zu Anfang die Eingabeprozedur der Zeit unter Verwendung der NXT eigenen Tasten.
task main()
{
bool h_aktion;
w_min = false;
w_h = false;
h_aktion = false;
btn_reset();
min = 30;
h = 6;
ClearScreen();
TextOut(28,LCD_LINE3,"WELCOME!");
TextOut(24,LCD_LINE8,"SET TIME  >>");
while(! i3)
{
i3 = ButtonState(BTN2);
}
btn_reset();
Wait(500);
show_set(false);
while(! i1)
{
i1 = ButtonState(BTN4);
i2 = ButtonState(BTN3);
i3 = ButtonState(BTN2);
  if(i2)
  {
  min_minus();
  show_set(false);
  }
  else
  {
    if(i3)
    {
    min_plus();
    show_set(false);
    }
  }
  Wait(400);
}
Wait(500);
show_set(true);
btn_reset();
while(! i1)
{
i1 = ButtonState(BTN4);
i2 = ButtonState(BTN3);
i3 = ButtonState(BTN2);
  if(i2)
  {
  h_minus();
  show_set(true);
  }
  else
  {
    if(i3)
    {
    h_plus();
    show_set(true);
    }
  }
  ResetTachoCount(OUT_BC);
  Wait(400);
}
btn_reset();
show();
start set_min;
start set_h;
      while(! w_min && ! w_h){}
  while(true)
  {
    if(min <= 58)
    {
      min = min + 1;
    }
    else
    {
      min = 0;
      h_aktion = true;
        if(h <= 22)
        {
          h = h + 1;
        }
        else
        {
          h = 0;
        }
    }
      repeat(60)
      {
      Wait(1000);
      }
    show();
    start min_mech_plus;
      if(h_aktion)
      {
        h_aktion = false;
        start h_mech_plus;
      }
  }
}