public void setup() {

    brek = new AudioSample[4][4];
    // load audio samples

    minim = new Minim(this);

    for (int i = 0; i < 4; i++) {
      println("break-beat-0" + (i + 1) + ".mp3");
      brek[i][0] = minim.loadSample("break-beat-0" + (i + 1) + ".mp3", 512);
      brek[i][1] = minim.loadSample("break-perc-0" + (i + 1) + ".mp3", 512);
      brek[i][2] = minim.loadSample("break-piano-0" + (i + 1) + ".mp3", 512);
      brek[i][3] = minim.loadSample("break-strings-0" + (i + 1) + ".mp3", 512);
    }

    size(cellSize * cols, cellSize * rows);

    //  bytes[0]=0;
    // bytes[1]=1;

    grid = new Cell[cols][rows];
    for (int i = 0; i < cols; i++) {
      for (int j = 0; j < rows; j++) {
        grid[i][j] = new Cell(i * cellSize, j * cellSize, cellSize, cellSize);
      }
    }
    println(Serial.list());

    String portName = Serial.list()[2];
    myPort = new Serial(this, portName, 9600);
  }
Example #2
0
  public void P2() {

    buttonP0.setColorBackground(gray_);
    buttonP1.setColorBackground(gray_);
    buttonP2.setColorBackground(green_);
    // Open the port you are using at the rate you want:
    if (portopen == true) {
      myPort.stop();
    }
    myPort = new Serial(this, Serial.list()[2], 9600);
    portopen = true;
  }
Example #3
0
  public void CONFIGoff() {

    myPort.write("j"); // exit config command
    buttonWRITE.setColorBackground(gray_);
    buttonREAD.setColorBackground(gray_);
    buttonCONFon.setColorBackground(gray_);
    buttonCONFoff.setColorBackground(green_);
    writeEnable = false;
    readEnable = false;
  }
Example #4
0
  public void CONFIGon() {

    myPort.write("i"); // enter config command
    buttonWRITE.setColorBackground(green_);
    buttonREAD.setColorBackground(green_);
    buttonCONFon.setColorBackground(green_);
    buttonCONFoff.setColorBackground(gray_);
    writeEnable = true;
    readEnable = true;
  }
  public void draw() {
    background(0);

    for (int i = 0; i < cols; i++) {
      for (int j = 0; j < rows; j++) {

        if ((i & 1) == 0) {
          // even rows white
          grid[i][j].display(255);
        } else {
          // odd rows gray
          grid[i][j].display(220);
        }
      }
    }

    if (play == true) {
      int j;
      if (millis() - starttime < delaytime) {
        count_up = (millis() - starttime);
        count_down = delaytime - count_up;
        steptimer = floor(4 / (delaytime / count_up));
        fill(0);
        //        textSize(12);
        //        text(steptimer, mouseX, mouseY);
        for (j = 0; j < rows; j++) {
          grid[steptimer][j].display(120);
          if (grid[steptimer][j].active) {
            grid[steptimer][j].trigger(steptimer, j);
          }
        }

        switch (steptimer) {
          case 0:
            uno = PApplet.parseByte(unbinary("00010001"));
            due = PApplet.parseByte(unbinary("00010001"));
            break;
          case 1:
            uno = PApplet.parseByte(unbinary("00100010"));
            due = PApplet.parseByte(unbinary("00100010"));
            break;
          case 2:
            uno = PApplet.parseByte(unbinary("01000100"));
            due = PApplet.parseByte(unbinary("01000100"));
            break;
          case 3:
            uno = PApplet.parseByte(unbinary("10001000"));
            due = PApplet.parseByte(unbinary("10001000"));
            break;
        }
        print(binary(uno));
        println(binary(due));

        myPort.write(due);
        myPort.write(uno);
        myPort.write(',');
      } else {
        starttime = millis();
        j = 0;
      }

      for (int i = 0; i < cols; i++) {
        for (int k = 0; k < rows; k++) {

          if (grid[i][k].active) {
            // even rows white

            if ((i + 4 * k) < 8) {
              uno |= (1 << i + 4 * k);
            } else {
              due |= (1 << (i + 4 * k) - 8);
            }
          } else {
            // odd rows gray

            if ((i + 4 * k) < 8) {
              uno &= ~(1 << i + 4 * k); // chiedete a vanzati [email protected]
            } else {
              due &= ~(1 << (i + 4 * k) - 8);
            }
          }
        }
      }
    }

    // print(binary(uno));
    // print(binary(due));

    myPort.write(due);
    myPort.write(uno);
    myPort.write(',');

    println();
  }
Example #6
0
  public void setup() {

    size(600, 280);
    background(75);

    textSize(28);
    fill(0, 120, 170); // blue
    text("EvvGC GUI", 20, 50);
    text(Version, 170, 50);

    // Define colors
    b1 = color(80);
    b2 = color(60);
    c1 = color(80, 80, 80);
    c2 = color(60, 61, 59);

    controlP5 = new ControlP5(this); // initialize the GUI controls

    // List all the available serial ports:
    println(Serial.list());

    commListMax = -1;
    for (int i = 0; i < Serial.list().length; i++) {
      commListMax = i;
    }

    /**
     * ****************************PID
     * cells************************************************************
     */
    PitchP = (controlP5.Numberbox) hideLabel(controlP5.addNumberbox("PitchP", 0, xPP, yPP, 40, 16));
    PitchP.setColorBackground(gray_);
    PitchP.setMin(0);
    PitchP.setDirection(Controller.HORIZONTAL);
    PitchP.setDecimalPrecision(2);
    PitchP.setMultiplier(0.01f);
    PitchP.setMax(2.54f);

    PitchD = (controlP5.Numberbox) hideLabel(controlP5.addNumberbox("PitchD", 0, xPD, yPD, 40, 16));
    PitchD.setColorBackground(gray_);
    PitchD.setMin(0);
    PitchD.setDirection(Controller.HORIZONTAL);
    PitchD.setDecimalPrecision(2);
    PitchD.setMultiplier(0.01f);
    PitchD.setMax(1);

    RollP = (controlP5.Numberbox) hideLabel(controlP5.addNumberbox("RollP", 0, xRP, yRP, 40, 16));
    RollP.setColorBackground(gray_);
    RollP.setMin(0);
    RollP.setDirection(Controller.HORIZONTAL);
    RollP.setDecimalPrecision(2);
    RollP.setMultiplier(0.01f);
    RollP.setMax(2.54f);

    RollD = (controlP5.Numberbox) hideLabel(controlP5.addNumberbox("RollD", 0, xRD, yRD, 40, 16));
    RollD.setColorBackground(gray_);
    RollD.setMin(0);
    RollD.setDirection(Controller.HORIZONTAL);
    RollD.setDecimalPrecision(2);
    RollD.setMultiplier(0.01f);
    RollD.setMax(1);

    YawP = (controlP5.Numberbox) hideLabel(controlP5.addNumberbox("YawP", 0, xYP, yYP, 40, 16));
    YawP.setColorBackground(gray_);
    YawP.setMin(0);
    YawP.setDirection(Controller.HORIZONTAL);
    YawP.setDecimalPrecision(2);
    YawP.setMultiplier(0.01f);
    YawP.setMax(2.54f);

    YawD = (controlP5.Numberbox) hideLabel(controlP5.addNumberbox("YawD", 0, xYD, yYD, 40, 16));
    YawD.setColorBackground(gray_);
    YawD.setMin(0);
    YawD.setDirection(Controller.HORIZONTAL);
    YawD.setDecimalPrecision(2);
    YawD.setMultiplier(0.01f);
    YawD.setMax(1);

    /**
     * ****************************Power
     * cells************************************************************
     */
    PitchPWR =
        (controlP5.Numberbox)
            hideLabel(controlP5.addNumberbox("PitchPWR", 0, xPPWR, yPPWR, 40, 16));
    PitchPWR.setColorBackground(gray_);
    PitchPWR.setMin(0);
    PitchPWR.setDirection(Controller.HORIZONTAL);
    PitchPWR.setDecimalPrecision(0);
    PitchPWR.setMultiplier(1);
    PitchPWR.setMax(100);

    RollPWR =
        (controlP5.Numberbox) hideLabel(controlP5.addNumberbox("RollPWR", 0, xRPWR, yRPWR, 40, 16));
    RollPWR.setColorBackground(gray_);
    RollPWR.setMin(0);
    RollPWR.setDirection(Controller.HORIZONTAL);
    RollPWR.setDecimalPrecision(0);
    RollPWR.setMultiplier(1);
    RollPWR.setMax(100);

    YawPWR =
        (controlP5.Numberbox) hideLabel(controlP5.addNumberbox("YawPWR", 0, xYPWR, yYPWR, 40, 16));
    YawPWR.setColorBackground(gray_);
    YawPWR.setMin(0);
    YawPWR.setDirection(Controller.HORIZONTAL);
    YawPWR.setDecimalPrecision(0);
    YawPWR.setMultiplier(1);
    YawPWR.setMax(100);

    /**
     * ****************************Calibration
     * cells************************************************************
     */
    RollCal =
        (controlP5.Numberbox)
            hideLabel(controlP5.addNumberbox("RollCal", 0, xRollCal, yRollCal, 40, 16));
    RollCal.setColorBackground(gray_);
    RollCal.setMin(-10);
    RollCal.setDirection(Controller.HORIZONTAL);
    RollCal.setDecimalPrecision(1);
    RollCal.setMultiplier(0.2f);
    RollCal.setMax(10);
    buttonZeroRoll = controlP5.addButton("ZERO", 1, 535, 200, 40, 16);
    buttonZeroRoll.setColorBackground(gray_);

    /**
     * **************************Buttons********************************************************************
     */
    buttonWRITE = controlP5.addButton("WRITE", 1, 500, 248, 60, 20);
    buttonWRITE.setColorBackground(gray_);
    buttonREAD = controlP5.addButton("READ", 1, 40, 248, 60, 20);
    buttonREAD.setColorBackground(gray_);

    buttonCONFon = controlP5.addButton("CONFIGon", 1, 400, 10, 60, 60);
    buttonCONFon.setColorBackground(gray_);
    buttonCONFoff = controlP5.addButton("CONFIGoff", 1, 330, 10, 60, 60);
    buttonCONFoff.setColorBackground(gray_);

    buttonP0 = controlP5.addButton("P0", 1, 490, 5, 20, 20);
    buttonP0.setColorBackground(gray_);
    buttonP1 = controlP5.addButton("P1", 1, 490, 30, 20, 20);
    buttonP1.setColorBackground(gray_);
    buttonP2 = controlP5.addButton("P2", 1, 490, 55, 20, 20);
    buttonP2.setColorBackground(gray_);

    buttonRCOff = controlP5.addButton("RC_OFF", 1, 450, 122, 65, 20);
    buttonRCOff.setColorBackground(gray_);
    buttonRCOn = controlP5.addButton("RC_ON", 1, 450, 100, 65, 20);
    buttonRCOn.setColorBackground(gray_);

    buttonYawRC = controlP5.addButton("Yaw_RC_Pan", 1, 520, 100, 75, 20);
    buttonYawRC.setColorBackground(gray_);
    buttonYawAut = controlP5.addButton("Yaw_Auto_Pan", 1, 520, 122, 75, 20);
    buttonYawAut.setColorBackground(gray_);

    buttonCONFoff.setColorBackground(green_);
  }
Example #7
0
  public void READ() {
    if (readEnable == false) return;

    myPort.write("g"); // sends get values command

    while (i < 200000000) {
      i++;
    } // delay
    i = 0;

    // myPort.write("OK");
    readStatus = "Can't Read";

    if (myPort.read() == 'x') {
      PitchP.setValue(myPort.read() / 100.00f);
      RollP.setValue(myPort.read() / 100.00f);
      YawP.setValue(myPort.read() / 100.00f);

      PitchD.setValue(myPort.read() / 100.00f);
      RollD.setValue(myPort.read() / 100.00f);
      YawD.setValue(myPort.read() / 100.00f);

      PitchPWR.setValue(myPort.read());
      RollPWR.setValue(myPort.read());
      YawPWR.setValue(myPort.read());

      RCcontrol = PApplet.parseChar(myPort.read());
      YawRCon = PApplet.parseChar(myPort.read());

      RollCal.setValue((myPort.read() - 100.00f) / 10.00f);

      if (RCcontrol == '0') {
        buttonRCOff.setColorBackground(green_);
        buttonRCOn.setColorBackground(gray_);
      }
      if (RCcontrol == '1') {
        buttonRCOff.setColorBackground(gray_);
        buttonRCOn.setColorBackground(green_);
      }

      if (YawRCon == '0') {
        buttonYawRC.setColorBackground(gray_);
        buttonYawAut.setColorBackground(green_);
      }
      if (YawRCon == '1') {
        buttonYawRC.setColorBackground(green_);
        buttonYawAut.setColorBackground(gray_);
      }

      readStatus = "Read OK";
    }
  }
Example #8
0
  public void WRITE() {
    if (writeEnable == false) return;

    myPort.write("h");

    myPort.write(PApplet.parseInt(PitchP.value() * 100));
    myPort.write(PApplet.parseInt(RollP.value() * 100));
    myPort.write(PApplet.parseInt(YawP.value() * 100));

    myPort.write(PApplet.parseInt(PitchD.value() * 100));
    myPort.write(PApplet.parseInt(RollD.value() * 100));
    myPort.write(PApplet.parseInt(YawD.value() * 100));

    myPort.write(PApplet.parseInt(PitchPWR.value()));
    myPort.write(PApplet.parseInt(RollPWR.value()));
    myPort.write(PApplet.parseInt(YawPWR.value()));

    myPort.write(RCcontrol);
    myPort.write(YawRCon);

    myPort.write(PApplet.parseInt(RollCal.value() * 10 + 100));
    // println (RollCal.value());
    // println (int (RollCal.value()*10+100));

    readStatus = "Write OK";
  }
Example #9
0
  public void draw() {
    // String Serial.list()[];
    // size(600, 280);
    // background(80);

    fill(70);
    strokeWeight(0);
    stroke(35); // 75
    rect(0, 80, 600, 155, 0);

    fill(70);
    strokeWeight(0);
    stroke(35);
    rect(440, 80, 600, 155, 0);

    fill(75);
    strokeWeight(0);
    stroke(80);
    rect(0, 240, 600, 100, 0);

    fill(255);

    // Background
    // setGradient(0, 0, width, 80, c2, c1, Y_AXIS);

    textSize(12);
    text("Pitch P:", 35, 112);
    textSize(12);
    text("Pitch D:", 155, 112);

    textSize(12);
    text("Roll P:", 38, 162);
    textSize(12);
    text("Roll D:", 158, 162);

    textSize(12);
    text("Yaw P:", 38, 211);
    textSize(12);
    text("Yaw D:", 158, 211);

    textSize(12);
    text("Pitch Power:             %", 301, 112);
    textSize(12);
    text("Roll Power:             %", 307, 162);
    textSize(12);
    text("Yaw Power:             %", 305, 212);

    textSize(12);
    text("Roll Calibration (degr.)", 460, 190);

    textSize(16);
    // fill(0, 102, 153, 204);
    // text("Connected to:",400,45); text(Serial.list()[0],515,45);
    // text("Connected to:",400,45); text(Serial.list()[1],515,65);
    // text("Connected to:",400,45); text(Serial.list()[2],515,65);

    if (printlist == true) {
      for (int i = 0; i <= commListMax; i++) {
        text(Serial.list()[i], 515, 21 + i * 25);
      }
      printlist = false;
    }

    textSize(12);
    text(readStatus, 110, 263);

    if (PitchP.value() == 0) PitchP.setValue(0.01f);
    if (RollP.value() == 0) RollP.setValue(0.01f);
    if (YawP.value() == 0) YawP.setValue(0.01f);

    if (PitchD.value() == 0) PitchD.setValue(0.01f);
    if (RollD.value() == 0) RollD.setValue(0.01f);
    if (YawD.value() == 0) YawD.setValue(0.01f);

    if (PitchPWR.value() == 0) PitchPWR.setValue(1);
    if (RollPWR.value() == 0) RollPWR.setValue(1);
    if (YawPWR.value() == 0) YawPWR.setValue(1);

    // if(RollCal.value()==-9.9)RollCal.setValue(-9.9);

  }