public void draw(int[] pixels) {
frameCount++;
parent.println("draw!");
String data = "";
data += "task.animation.set(leds, 50, ";
if (isLoggedIn) { // && serverIsReady){
for (int i = 0; i < pixels.length; i++) {
String value = Integer.toHexString(pixels[i]);
value = value.substring(2, value.length());
data += "#" + value + ",";
}
data = data.substring(0, data.length() - 1);
data += ")\n";
parent.println(data);
lumoClient.write(data);
serverIsReady = false;
}
}
/*
Perform Simulation
*/
public void simulate(float dt) {
// Accelerate angular speed
float requiredSpeed = targetAngularSpeed - angularSpeed;
float angularAccel = requiredSpeed / dt;
angularAccel = PApplet.constrain(angularAccel, -maxAngularAccel, maxAngularAccel);
// Limit Angular speed
angularSpeed += angularAccel * dt;
angularSpeed = PApplet.constrain(angularSpeed, -maxAngularSpeed, maxAngularSpeed);
// Orientation Simulation
orientation += angularSpeed * dt;
// Position simulation
PVector worldRequiredSpeed = targetSpeed.get();
worldRequiredSpeed.rotate(orientation);
worldRequiredSpeed.sub(speed);
// PVector worldRequiredSpeed = worldTargetSpeed.get();
float dSpeed = worldRequiredSpeed.mag();
float dAcell = dSpeed / dt;
float dForce = Math.min(dAcell * getMass(), motorForce);
worldRequiredSpeed.normalize();
worldRequiredSpeed.mult(dForce);
force.add(worldRequiredSpeed);
super.simulate(dt);
}
// \u30c7\u30fc\u30bf\u3092\u30ea\u30b9\u30c8\u306b\u683c\u7d0d\u3057\u3066\u53d6\u5f97
public ArrayList<dotObj> getDataList(String[] lines, int targetChannel) {
ArrayList<dotObj> retList = new ArrayList<dotObj>();
// \u5168\u30c7\u30fc\u30bf\u3092\u53c2\u7167\u3057\u3066\u5fc5\u8981\u306a\u60c5\u5831\u3092\u53d6\u308a\u51fa\u3059
int index = 0;
for (int i = 0; i < lines.length; i++) {
// ','\u3067\u533a\u5207\u308a\u914d\u5217\u306b\u683c\u7d0d
String data[] = split(lines[i], ',');
// channel, date, valuse
// \u306e\u9806\u3067\u30c7\u30fc\u30bf\u304c\u683c\u7d0d\u3055\u308c\u3066\u3044\u308b
int channel = PApplet.parseInt(data[0]); // \u30c1\u30e3\u30f3\u30cd\u30eb
String timeStamp = data[1]; // \u65e5\u4ed8
float val = PApplet.parseFloat(data[2]); // \u5024
if (channel == targetChannel) {
// println("channel: " + channel);
// println("date : " + timeStamp);
// println("val : " + val);
// \u53d6\u5f97\u3057\u305f\u30c7\u30fc\u30bf\u3092\u30aa\u30d6\u30b8\u30a7\u30af\u30c8\u306b\u30bb\u30c3\u30c8\u3057\u3001\u914d\u5217\u306b\u683c\u7d0d
float m = map(val, -0.5f, 0.5f, height / 4, height);
dotObj theObj = new dotObj(index * width / 70, m, 0);
theObj.channel = channel;
theObj.timeStamp = timeStamp;
theObj.val = val;
retList.add(theObj);
index++;
}
}
return retList;
}
public void callOriginal() {
camPos =
new PVector(
p.width * 0.5f, p.height * 0.5f, (p.height * 0.5f) / p.tan(p.PI * 30.0f / 180.0f));
camCenter = new PVector(p.width * 0.5f, p.height * 0.5f, 0f);
p.camera(camPos.x, camPos.y, camPos.z, camCenter.x, camCenter.y, camCenter.z, 0f, 1f, 0f);
}
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";
}
public void draw(PApplet canvas, float scale) {
PVector orient = PVector.fromAngle(orientation);
orient.mult(scale * getRadius());
float x = (float) position.x * scale;
float y = (float) position.y * scale;
float diameter = getRadius() * 2 * scale;
canvas.fill(teamColor);
canvas.stroke(0);
canvas.ellipse(x, y, diameter, diameter);
canvas.line(x, y, x + (float) orient.x, y + (float) orient.y);
// Delegate Decoration to Robot
float heading = orient.heading();
float drawScale = 100f / scale * getRadius();
canvas.translate(x, y);
canvas.rotate(heading);
canvas.scale(drawScale);
// TODO: How to resolve scale, so that teams don't have to mind it also...
decorateRobot(canvas);
canvas.scale(1f / drawScale);
canvas.rotate(-heading);
canvas.translate(-x, -y);
}
/**
* Constructor.
*
* @param inpParApp Parent PApplet.
* @param inpResNbr Resolution of the sphere.
* @param inpModelRadiusNbr Radius of the sphere.
* @param inpExtDatFilePathTxt Path to an external data file for manipulating the sphere.
*/
public Sphere(
PApplet inpParApp, float inpResNbr, float inpModelRadiusNbr, String inpExtDatFilePathTxt) {
_parApp = inpParApp;
_resNbr = inpResNbr;
_modelRadiusNbr = inpModelRadiusNbr;
_latitudeLnCnt = (int) (180 / _resNbr);
_longitudeLnCnt = (int) (360 / _resNbr);
// The number of vertices is the number of longitudinal lines multiplied by the number of
// latitudinal lines minus 1, plus 2 vertices for the poles.
int vertexCnt = _longitudeLnCnt * (_latitudeLnCnt - 1) + 2;
_latitudeDegs = new float[vertexCnt];
_longitudeDegs = new float[vertexCnt];
_radiusLenNbrs = new float[vertexCnt];
// createVertices(0);
crteVertices();
FROM_CLR_NBR = _parApp.color(144, 29, 31);
TO_CLR_NBR = _parApp.color(215, 180, 15);
_loadFilePathTxt = inpExtDatFilePathTxt;
loadExtData();
}
public void initXMLObject() {
numProfiles = xmlFeed.getChildCount();
println("NUM PROFILES: " + numProfiles);
for (int i = 0; i < numProfiles; i++) {
XMLElement profile = xmlFeed.getChild(i);
/// *
try {
headerList.add(profile.getChild(0).getContent());
nameList.add(profile.getChild(1).getContent());
blurbList.add(profile.getChild(2).getContent());
// videoPathList.add(profile.getChild(3).getContent());
thePopUp.videoPath.add(profile.getChild(3).getContent());
latList.add(profile.getChild(4).getContent());
longList.add(profile.getChild(5).getContent());
pApp.println("Title= " + profile.getChild(0).getContent());
pApp.println("Name= " + profile.getChild(1).getContent());
pApp.println("Blurb= " + profile.getChild(2).getContent());
// pApp.println("video = " + profile.getChild(3).getContent());
pApp.println("Address = " + profile.getChild(4).getContent());
// pApp.println("long = " + profile.getChild(5).getContent());
// pApp.println(" ");
pApp.println(" ");
} catch (Exception e) {
println("XML init error: " + e);
}
}
/// now that the popup video array has data, init the video
thePopUp.initVideo();
/// convert the lat and long string to floats
initLocations();
}
/**
* Set the Quaternion from a (supposedly correct) 3x3 rotation matrix.
*
* <p>The matrix is expressed in European format: its three columns are the images by the rotation
* of the three vectors of an orthogonal basis.
*
* <p>{@link #fromRotatedBasis(PVector, PVector, PVector)} sets a Quaternion from the three axis
* of a rotated frame. It actually fills the three columns of a matrix with these rotated basis
* vectors and calls this method.
*
* @param m the 3*3 matrix of float values
*/
public final void fromRotationMatrix(float m[][]) {
// Compute one plus the trace of the matrix
float onePlusTrace = 1.0f + m[0][0] + m[1][1] + m[2][2];
if (onePlusTrace > 1E-5f) {
// Direct computation
float s = PApplet.sqrt(onePlusTrace) * 2.0f;
this.x = (m[2][1] - m[1][2]) / s;
this.y = (m[0][2] - m[2][0]) / s;
this.z = (m[1][0] - m[0][1]) / s;
this.w = 0.25f * s;
} else {
// Computation depends on major diagonal term
if ((m[0][0] > m[1][1]) & (m[0][0] > m[2][2])) {
float s = PApplet.sqrt(1.0f + m[0][0] - m[1][1] - m[2][2]) * 2.0f;
this.x = 0.25f * s;
this.y = (m[0][1] + m[1][0]) / s;
this.z = (m[0][2] + m[2][0]) / s;
this.w = (m[1][2] - m[2][1]) / s;
} else if (m[1][1] > m[2][2]) {
float s = PApplet.sqrt(1.0f + m[1][1] - m[0][0] - m[2][2]) * 2.0f;
this.x = (m[0][1] + m[1][0]) / s;
this.y = 0.25f * s;
this.z = (m[1][2] + m[2][1]) / s;
this.w = (m[0][2] - m[2][0]) / s;
} else {
float s = PApplet.sqrt(1.0f + m[2][2] - m[0][0] - m[1][1]) * 2.0f;
this.x = (m[0][2] + m[2][0]) / s;
this.y = (m[1][2] + m[2][1]) / s;
this.z = 0.25f * s;
this.w = (m[0][1] - m[1][0]) / s;
}
}
normalize();
}
public void sendDataString(int addressH, int addressL, String data) {
if (DEBUG) System.out.println("executing sendString");
String cmdString = data;
int[] myCommand = new int[2];
myCommand[0] = TRANSMIT_REQUEST; // frame identifier
myCommand[1] = 0x01; // frame type
// break up the address and append the bytes of it:
byte thisByte = 0;
// get each byte from the 4-byte int:
for (int b = 3; b > -1; b--) {
thisByte = (byte) (addressH >> (8 * b));
myCommand = parent.append(myCommand, thisByte);
}
// same for addressL:
for (int b = 3; b > -1; b--) {
thisByte = (byte) (addressL >> (8 * b));
myCommand = parent.append(myCommand, thisByte);
}
// 16-bit address:
myCommand = parent.append(myCommand, 0xFF);
myCommand = parent.append(myCommand, 0xFE);
myCommand = parent.append(myCommand, 0x00); // broadcast radius
myCommand = parent.append(myCommand, 0x00); // options
// append the cmdString to the array
for (int i = 0; i < cmdString.length(); i++) {
myCommand = parent.append(myCommand, (int) (cmdString.charAt(i)));
}
sendPacket(myCommand);
}
// A function to rotate a vector
public void rotateVector(PVector v, float theta) {
float m = v.mag();
float a = v.heading2D();
a += theta;
v.x = m * PApplet.cos(a);
v.y = m * PApplet.sin(a);
}
public int[] getPacket(byte[] someFileArray) {
boolean gotAPacket = false; // whether the first byte was 0x7E
int packetLength = -1; // length of the dataArray
int[] thisdataArray = null; // the dataArray to return
int checksum = -1; // the checksum as received
int localChecksum = -1; // the chacksum as we calculate it
if (DEBUG) System.out.println("fileIndex: " + fileIndex);
if (DEBUG) System.out.println("file length: " + fileArray.length);
// make sure you have a 0x7E and at least three bytes
if (getNextByte() == 0x7E && fileArray.length > 2) {
gotAPacket = true;
}
// if the header byte is good, try the rest:
if (gotAPacket) {
// read two bytes
if (bytesAvailable() >= 2) {
int lengthMSB = getNextByte(); // high byte for length of packet
int lengthLSB = getNextByte(); // low byte for length of packet
// convert to length value
packetLength = (lengthLSB + (lengthMSB << 8));
if (DEBUG) System.out.println("length: " + packetLength);
}
// read bytes until you've reached the length
if (bytesAvailable() >= packetLength && packetLength > 0) {
// make an array to hold the data frame:
thisdataArray = new int[packetLength];
// read all the bytes except the last one into the dataArray array:
for (int thisByte = 0; thisByte < packetLength; thisByte++) {
thisdataArray[thisByte] = getNextByte();
if (DEBUG) System.out.print(parent.hex(thisdataArray[thisByte], 2) + " ");
}
if (bytesAvailable() >= 1) {
// get the checksum:
checksum = getNextByte();
}
// calculate the checksum of the received dataArray:
localChecksum = checkSum(thisdataArray);
// if they're not the same, we have bad data:
if (localChecksum != checksum) {
if (DEBUG) System.out.println("bad checksum. Local: " + parent.hex(localChecksum % 256));
if (DEBUG) System.out.println(" remote: " + parent.hex(checksum));
// if the checksums don't add up, clear the dataArray array:
thisdataArray = null;
}
}
}
// makes a nice printing for debugging:
if (DEBUG) System.out.println();
// return the data frame. If it's null, you got a bad packet.
return thisdataArray;
}
public static void main(String[] passedArgs) {
String[] appletArgs = new String[] {"crop_graphics_tri_large"};
if (passedArgs != null) {
PApplet.main(concat(appletArgs, passedArgs));
} else {
PApplet.main(appletArgs);
}
}
public void registerEvents() {
// p.registerMouseEvent(this);
// p.registerKeyEvent(this);
p.registerMethod("mouseEvent", this);
p.registerMethod("keyEvent", this);
p.addMouseWheelListener(this);
callOriginal();
}
public static void main(String[] passedArgs) {
String[] appletArgs = new String[] {"EvvGC_GUI_v0_4"};
if (passedArgs != null) {
PApplet.main(concat(appletArgs, passedArgs));
} else {
PApplet.main(appletArgs);
}
}
public static void main(String[] passedArgs) {
String[] appletArgs = new String[] {"shapes_shapes"};
if (passedArgs != null) {
PApplet.main(concat(appletArgs, passedArgs));
} else {
PApplet.main(appletArgs);
}
}
public static void main(String[] passedArgs) {
String[] appletArgs = new String[] {"getDataFromXively"};
if (passedArgs != null) {
PApplet.main(concat(appletArgs, passedArgs));
} else {
PApplet.main(appletArgs);
}
}
public static void main(String[] passedArgs) {
String[] appletArgs = new String[] {"GoogleBillboard"};
if (passedArgs != null) {
PApplet.main(concat(appletArgs, passedArgs));
} else {
PApplet.main(appletArgs);
}
}
protected static String getBasePath(PApplet parent, String filename) {
// Obtaining the path
File file = new File(parent.dataPath(filename));
if (!file.exists()) {
file = parent.sketchFile(filename);
}
String absolutePath = file.getAbsolutePath();
return absolutePath.substring(0, absolutePath.lastIndexOf(File.separator));
}
/**
* Returns the exponential of the Quaternion.
*
* @see #log()
*/
public final Quaternion exp() {
float theta = PApplet.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
if (theta < 1E-6f) return new Quaternion(this.x, this.y, this.z, PApplet.cos(theta));
else {
float coef = PApplet.sin(theta) / theta;
return new Quaternion(this.x * coef, this.y * coef, this.z * coef, PApplet.cos(theta));
}
}
public void avoid(ArrayList obstacles) {
// Make a vector that will be the position of the object
// relative to the Boid rotated in the direction of boid's velocity
PVector closestRotated = new PVector(sight + 1, sight + 1);
float closestDistance = 99999;
Obstacle avoid = null;
// Let's look at each obstacle
for (int i = 0; i < obstacles.size(); i++) {
Obstacle o = (Obstacle) obstacles.get(i);
float d = PVector.dist(loc, o.loc);
PVector dir = vel.get();
dir.normalize();
PVector diff = PVector.sub(o.loc, loc);
// Now we use the dot product to rotate the vector that points from boid to obstacle
// Velocity is the new x-axis
PVector rotated = new PVector(diff.dot(dir), diff.dot(getNormal(dir)));
// Is the obstacle in our path?
if (PApplet.abs(rotated.y) < (o.radius + r)) {
// Is it the closest obstacle?
if ((rotated.x > 0) && (rotated.x < closestRotated.x)) {
closestRotated = rotated;
avoid = o;
}
}
}
// Can we actually see the closest one?
if (PApplet.abs(closestRotated.x) < sight) {
// The desired vector should point away from the obstacle
// The closer to the obstacle, the more it should steer
PVector desired =
new PVector(closestRotated.x, -closestRotated.y * sight / closestRotated.x);
desired.normalize();
desired.mult(closestDistance);
desired.limit(maxspeed);
// Rotate back to the regular coordinate system
rotateVector(desired, vel.heading2D());
// Draw some debugging stuff
if (debug) {
stroke(0);
line(loc.x, loc.y, loc.x + desired.x * 10, loc.y + desired.y * 10);
avoid.highlight(true);
}
// Apply Reynolds steering rules
desired.sub(vel);
desired.limit(maxforce);
acc.add(desired);
}
}
public static void main(String[] passedArgs) {
String[] appletArgs =
new String[] {"--full-screen", "--bgcolor=#666666", "--hide-stop", "build"};
if (passedArgs != null) {
PApplet.main(concat(appletArgs, passedArgs));
} else {
PApplet.main(appletArgs);
}
}
public void processSerialData() {
byte[] inBuf = new byte[20];
switch (serial.read()) {
case 'A':
// wait for all data arrived
while (serial.available() < 16) {}
// read all data
serial.readBytes(inBuf);
Acc_RAW = (inBuf[1] << 8) + (inBuf[0] & 0xFF);
Gyro_RAW = (inBuf[3] << 8) + (inBuf[2] & 0xFF);
// int intbit = 0;
// intbit = (inBuf[7] << 24) | ((inBuf[6] & 0xFF) << 16) | ((inBuf[5] & 0xFF) << 8) |
// (inBuf[4] & 0xFF);
// Angle = Float.intBitsToFloat(intbit);
int AngleInt = (inBuf[5] << 8) + (inBuf[4] & 0xFF);
Angle = PApplet.parseFloat(AngleInt) / 10;
Acc_Angle = (inBuf[7] << 8) + (inBuf[6] & 0xFF);
Gyro_Rate = (inBuf[9] << 8) + (inBuf[8] & 0xff);
Drive = (inBuf[11] << 8) + (inBuf[10] & 0xFF);
statusFlag = (inBuf[13] << 8) + (inBuf[12] & 0xFF);
int BatLevelInt = (inBuf[15] << 8) + (inBuf[14] & 0xFF);
Steer = (inBuf[17] << 8) + (inBuf[16] & 0xFF);
BatLevel = PApplet.parseFloat(BatLevelInt) / 10;
println(
"Acc="
+ Acc_RAW
+ " Gyro="
+ Gyro_RAW
+ " Angle="
+ Angle
+ " Acc_Angle="
+ Acc_Angle
+ " Gyro_Rate="
+ Gyro_Rate
+ " Drive="
+ Drive
+ " Status="
+ statusFlag);
break;
case 'E':
// wait for all data arrived
while (serial.available() < 6) {}
// read all data
serial.readBytes(inBuf);
int P = (inBuf[1] << 8) + (inBuf[0] & 0xFF);
int I = (inBuf[3] << 8) + (inBuf[2] & 0xFF);
int D = (inBuf[5] << 8) + (inBuf[4] & 0xFF);
conf_KP.setValue(P);
conf_KI.setValue(I);
conf_KD.setValue(D);
println("P=" + P + " I=" + I + " D=" + D);
break;
}
serial.clear();
}
public InteractModel setupDisplay() {
parent.noStroke(); // NoStroke para que muestre el material
// parent.stroke(255,0,0);
// parent.strokeWeight(1);
parent.rotateX(PApplet.radians(90));
parent.rotateY(PApplet.radians(180));
return this;
}
/**
* Returns the logarithm of the Quaternion.
*
* @see #exp()
*/
public final Quaternion log() {
// Warning: this method should not normalize the Quaternion
float len = PApplet.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
if (len < 1E-6f) return new Quaternion(this.x, this.y, this.z, 0.0f, false);
else {
float coef = PApplet.acos(this.w) / len;
return new Quaternion(this.x * coef, this.y * coef, this.z * coef, 0.0f, false);
}
}
public void addPlant(int type, int mouseX, int mouseY) {
if (mouseX <= left || mouseX >= right || mouseY <= top || mouseY >= bottom) return;
println(mouseX, mouseY);
int colIndex = floor((mouseX - left) / wSpacing);
int rowIndex = floor((mouseY - top) / hSpacing);
int x = PApplet.parseInt(left + colIndex * wSpacing);
int y = PApplet.parseInt(top + rowIndex * hSpacing);
if (plants[colIndex][rowIndex] == null) plants[colIndex][rowIndex] = new Plant(type, x, y);
}
public Display(PApplet p, int x, int y, int w, int h) {
this.x = x;
this.y = y;
this.w = w;
this.h = h;
this.p = p;
piece1 = p.loadImage("images/red_ball.png");
piece2 = p.loadImage("images/blue_ball.png");
}
public static void main(String[] passedArgs) {
String[] appletArgs =
new String[] {
"--full-screen", "--bgcolor=#666666", "--stop-color=#cccccc", "fruitloop_processing"
};
if (passedArgs != null) {
PApplet.main(concat(appletArgs, passedArgs));
} else {
PApplet.main(appletArgs);
}
}
public DisplayFrame() {
this.setSize(1000, 800); // The window Dimensions
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
javax.swing.JPanel panel = new javax.swing.JPanel();
panel.setBounds(20, 20, 1000, 800);
PApplet sketch = new CTCOffice();
panel.add(sketch);
this.add(panel);
sketch.init(); // this is the function used to start the execution of the sketch
this.setVisible(true);
this.setTitle("Breathless Bovine: CTC Office by Jake Lyons");
}
private Method findCallback(final String name) {
try {
return parent.getClass().getMethod(name, this.getClass());
} catch (Exception e) {
}
// Permit callback(Object) as alternative to callback(Serial).
try {
return parent.getClass().getMethod(name, Object.class);
} catch (Exception e) {
}
return null;
}
