/*-----------------------------------------------------------------------------*/  
void ButtonsCheckConfig()  // Main panel controls
{
    Grid = get(57,21,751,751);
    background(bg);
    image(Grid,57,21);

    BtnConfig.update();
    if (BtnConfig.released)
    {
      ConfigFlag = true;
      InputFieldsConfig();
    }
    BtnConfig.display();
    
    BtnQuit.update();
    if (BtnQuit.released)
    {

      exit();
    }
    BtnQuit.display();
    
    BtnSendSpeed.update();
    if (BtnSendSpeed.released)
    {
      // 1 int (range -500 mm/s +500 mm/s)
      DesSpeed = RangeCheckInt(InputSpeed.getValue(), -500, 500);
      InputSpeed.setValue(nf(DesSpeed,3));
      TxIntValue[0] = DesSpeed;
      TxData(0, 'W', 1, 1);
    }
    BtnSendSpeed.display();
    
    BtnSendXY.update();
    if (BtnSendXY.released)
    {
      //2 int ( X, Y) (range -5000 mm +5000 mm)
      DesCoordX = RangeCheckInt(InputCoordX.getValue(), -5000, 5000);
      InputCoordX.setValue(nf(DesCoordX,4));
      DesCoordY = RangeCheckInt(InputCoordY.getValue(), -5000, 5000);
      InputCoordY.setValue(nf(DesCoordY,4));
      TxIntValue[0] = DesCoordX;
      TxIntValue[1] = DesCoordY;
      TxData(0, 'x', 2, 1);
    }
    BtnSendXY.display();
    
    BtnSendDist.update();
    if (BtnSendDist.released)
    {
      // 1 int (range -5000 mm + 5000 mm)
      DesDist = RangeCheckInt(InputDist.getValue(), -5000, 50000);
      InputDist.setValue(nf(DesDist,4));
      TxIntValue[0] = DesDist;
      TxData(0, 'D', 1, 1);
    }
    BtnSendDist.display();
    
    BtnSendReset.update();
    if (BtnSendReset.released)
    {
      TxData(0, '*', 0, 1);
    }
    BtnSendReset.display();
    
    BtnSendHalt.update();
    if (BtnSendHalt.released)
    {
      TxData(0, 'H', 0, 1);
    }
    BtnSendHalt.display();
    
    BtnSendVersion.update();
    if (BtnSendVersion.released)
    {
      int VerLen = 27;
      TxData(0, 'R', 0, 1);  // ask for all parameters
      Delay(VerLen);         // wait for data to be received
      
      if (PreInitRS232Flag)
      {
        SimulationRxVer();      // simulation
      }
    
      if (RxData('R',VerLen))
      {
        for (i=HeadLen; i < VerLen+HeadLen; i++)
        {
          Ver[i-HeadLen]= (char)(RxBuff[i]);
        }
      }
    }
    textAlign(RIGHT);
    String VerS = new String(Ver);
    text(VerS, 1148, 672); 
    BtnSendVersion.display();
    
    KnobSegment(); 
    GaugeAngle();
    GaugeSpeed();
    GaugeCurrent();
    ReleasedFlag = false;
}

/*-----------------------------------------------------------------------------*/
void ButtonsCheckRun()  // Config panel controls
{
    int Kp;
    int Ki;
    int Kd;
    int K;
    
    Grid = get(57,21,751,751);
    background(bgConfig);
    image(Grid,57,21);
    BtnRun.display();
    BtnRun.update();
    
    BtnQuit.update();
    if (BtnQuit.released)
    {
      exit();
    }
    BtnQuit.display();

    if (BtnRun.released)  
    {
      ConfigFlag = false;
      InputFieldsRun();
    }
    BtnRun.display();
    
    BtnSendCfgKSpeed1.update();
    if (BtnSendCfgKSpeed1.released)
    {
      // 3 int K x 10.000 (range 0 +9999)
      Kp = RangeCheckInt(InputSpeed1Kp.getValue(), 0, 9999);
      InputSpeed1Kp.setValue(nf(Kp,0));
      Ki = RangeCheckInt(InputSpeed1Ki.getValue(), 0, 9999);
      InputSpeed1Ki.setValue(nf(Ki,0));
      Kd = RangeCheckInt(InputSpeed1Kd.getValue(), 0, 9999);
      InputSpeed1Kd.setValue(nf(Kd,0));
      TxIntValue[0] = Kp;
      TxIntValue[1] = Ki;
      TxIntValue[2] = Kd;
      TxData(1, 'K', 3, 1);
    }
    BtnSendCfgKSpeed1.display();
    
    BtnSendCfgKSpeed2.update();
    if (BtnSendCfgKSpeed2.released)
    {
      // 3 int K x 10.000 (range 0 +9999)
      Kp = RangeCheckInt(InputSpeed2Kp.getValue(), 0, 9999);
      InputSpeed2Kp.setValue(nf(Kp,0));
      Ki = RangeCheckInt(InputSpeed2Ki.getValue(), 0, 9999);
      InputSpeed2Ki.setValue(nf(Ki,0));
      Kd = RangeCheckInt(InputSpeed2Kd.getValue(), 0, 9999);
      InputSpeed2Kd.setValue(nf(Kd,0));
      TxIntValue[0] = Kp;
      TxIntValue[1] = Ki;
      TxIntValue[2] = Kd;
      TxData(2, 'K', 3, 1);
    }
    BtnSendCfgKSpeed2.display();
    
    BtnSendCfgKAngle.update();
    if (BtnSendCfgKAngle.released)
    {
      // 3 int K x 10.000 (range 0 +9999)
      Kp = RangeCheckInt(InputAngleKp.getValue(), 0, 9999);
      InputAngleKp.setValue(nf(Kp,0));
      Ki = RangeCheckInt(InputAngleKi.getValue(), 0, 9999);
      InputAngleKi.setValue(nf(Ki,0));
      Kd = RangeCheckInt(InputAngleKd.getValue(), 0, 9999);
      InputAngleKd.setValue(nf(Kd,0));
      TxIntValue[0] = Kp;
      TxIntValue[1] = Ki;
      TxIntValue[2] = Kd;
      TxData(0, 'k', 3, 1);
    }
    BtnSendCfgKAngle.display();
    
    BtnSendCfgKDist.update();
    if (BtnSendCfgKDist.released)
    {
      // 3 int K x 10.000 (range 0 +9999)
      Kp = RangeCheckInt(InputDistKp.getValue(), 0, 9999);
      InputDistKp.setValue(nf(Kp,0));
      Ki = RangeCheckInt(InputDistKi.getValue(), 0, 9999);
      InputDistKi.setValue(nf(Ki,0));
      Kd = RangeCheckInt(InputDistKd.getValue(), 0, 9999);
      InputDistKd.setValue(nf(Kd,0));
      TxIntValue[0] = Kp;
      TxIntValue[1] = Ki;
      TxIntValue[2] = Kd;
      TxData(0, 'J', 3, 1);
    }
    BtnSendCfgKDist.display();
    
    BtnSendCfgWheels.update();
    if (BtnSendCfgWheels.released)
    {
      /* Axle size (micron / 10) 
         Ksp = constants for traveled distance calculation: 
         SPACE_ENC_4X (micron / 1.000.000 = picoM)
         3 long 
      */
      K = RangeCheckInt(InputAxle.getValue(), 0, 9999999);
      InputAxle.setValue(nf(K,0));
      TxIntValue[0] = K;
      
      K = RangeCheckInt(InputKsp1.getValue(), 0, 9999999);
      InputKsp1.setValue(nf(K,0));
      TxIntValue[1] = K;
      
      K = RangeCheckInt(InputKsp2.getValue(), 0, 9999999);
      InputKsp2.setValue(nf(K,0));
      TxIntValue[2] = K;
      
      TxData(0, 'M', 3, 2);
    }
    BtnSendCfgWheels.display();
    
    BtnSendCfgKvel.update();
    if (BtnSendCfgKvel.released)
    {
      /* Speed calculation K in micron/second = 298536736
	 Speed calculation K in m/s as a power of 2 to semplify dsPID elaboration
	 Kvel[] << 15 ( x 2^15) 
         2 long, 2 x 4 bytes
         for a detailde description see descrEng.txt in dsODO folder
      */
      K = RangeCheckInt(InputKvel1.getValue(), 0, 9999999);
      InputKvel1.setValue(nf(K,0));
      TxIntValue[0] = K;
      TxData(1, 'L', 1, 2);
      K = RangeCheckInt(InputKvel2.getValue(), 0, 9999999);
      InputKvel2.setValue(nf(K,0));
      TxIntValue[0] = K;
      TxData(2, 'L', 1, 2);
    }
    BtnSendCfgKvel.display();

      textAlign(LEFT);
      text("Available COM ports:",850,430);
      for(i=0;i<(SerialList.length);i++)
      {
        if (i == RS232ComPort)
        {
          fill(0,100,255);
        }
        else
        {
          fill(255,255,255);
        }
        text(i + " = " + SerialList[i],860,450 + (i*20));
      }
      fill(255,255,255);
    
    BtnSendCfgRS232.update();
    if (BtnSendCfgRS232.released)
    {
       RS232ComPort = RangeCheckInt(InputRS232Com.getValue(), 0, SerialList.length-1);
       RS232Bps = RangeCheckInt(InputRS232bps.getValue(), 1200, 115200);
       try
       { 
          if (! SimulationRS232Flag)
          {
            RS232Port = new Serial(this, Serial.list()[RS232ComPort], RS232Bps);
            PreInitRS232Flag = false;          // turn ON real RS232 sending
          }
          else
          {
            PreInitRS232Flag = true;          // still in simulation
          }
          CharTime = (115200 / RS232Bps) * 0.1; // waiting time is a function of bps
        }
        catch(Exception e)    // not a valid COM port
        {
          RS232ComPort = 99;
          PreInitRS232Flag = true;          // turn OFF real RS232 sending
        } 

       InputRS232Com.setValue(nf(RS232ComPort,0));
       InputRS232bps.setValue(nf(RS232Bps,0));
    }
    BtnSendCfgRS232.display();
    
    BtnSendCfgLoad.update();
    if (BtnSendCfgLoad.released)
    {
      LoadCfg();
    }
    BtnSendCfgLoad.display();
    
    BtnSendCfgSave.update();
    if (BtnSendCfgSave.released)
    {
      SaveCfg();
    }
    BtnSendCfgSave.display();
    
    ReleasedFlag = false;
}

/*-----------------------------------------------------------------------------*/
void KnobSegment()  // draw knob index
{
  float KnobX = 1162;
  float KnobY = 333;
  float KnobSegLength = 50;
  float KnobDx = mouseX - KnobX;
  float KnobDy = mouseY - KnobY;
  int Base = 3;
  pushMatrix();
  translate(KnobX, KnobY);
  if (mouseX >= KnobX-KnobSegLength && mouseX <= KnobX+KnobSegLength && 
      mouseY >= KnobY-KnobSegLength && mouseY <= KnobY+KnobSegLength &&
      mousePressed)
    {
      KnobAngle = atan2(KnobDy, KnobDx);  
    }
   rotate(KnobAngle);
   strokeWeight(7.0);
   stroke(67,85,100);
   triangle(0,-Base,0,Base,KnobSegLength,0);
   popMatrix();
   KnobAngle1=degrees(KnobAngle+(PI/2));
   textAlign(CENTER);
   text(nf(KnobAngle1,0,1), KnobX,KnobY+115);
   DesAngle = KnobAngle1;
}

/*-----------------------------------------------------------------------------*/
void GaugeAngle()
{
  float GaugeX = 950;
  float GaugeY = 333;
  float GaugeSegLength = 60;
  float Angle1 = 0;
  int Base = 2;
  pushMatrix();
  translate(GaugeX, GaugeY);
   rotate(MesAngle);
   strokeWeight(3.0);
   stroke(255,0,0);
   triangle(15,-Base,15,Base,GaugeSegLength,0);
   popMatrix();
   Angle1 = degrees(MesAngle+(PI/2));
   textAlign(CENTER);
   text(nf(Angle1,0,1), GaugeX,GaugeY+112);
}

/*-----------------------------------------------------------------------------*/
void GaugeSpeed()
{
  float GaugeX = 950;
  float GaugeY = 112;
  float GaugeSegLength = 60;
  float Speed1;
  float MinSpeed=-500;
  float MaxSpeed=500;
  float Speed = 0;
  int Base = 2;
  pushMatrix();
  translate(GaugeX, GaugeY);
  Speed = MesSpeed;
  if (Speed > 500) Speed = 500;
  if (Speed < -500) Speed = -500;
  Speed1 = Speed * (300 / (MaxSpeed-MinSpeed));
  Speed1=radians(Speed1-90);
   rotate((Speed1));
   strokeWeight(3.0);
   stroke(255,0,0);
   triangle(15,-Base,15,Base,GaugeSegLength,0);
   popMatrix();
   textAlign(CENTER);
   text(nf(Speed,0,1), GaugeX,GaugeY+105);
}

/*-----------------------------------------------------------------------------*/
void GaugeCurrent()
{
  float GaugeX = 1168;
  float GaugeY = 112;
  float GaugeSegLength = 60;
  float Current1 = 0;
  float MinCurrent=0;
  float MaxCurrent=1000;
  int Base = 2;
  pushMatrix();
  translate(GaugeX, GaugeY);
  Current1 = Current * (300 / (MaxCurrent-MinCurrent));
  Current1 = radians(Current1-240);
   rotate((Current1));
   strokeWeight(3.0);
   stroke(255,0,0);
   triangle(15,-Base,15,Base,GaugeSegLength,0);
   popMatrix();
   textAlign(CENTER);
   text(nf(Current,0,1), GaugeX,GaugeY+105);
}