001/* 002 * Copyright (c) 1998-2010 The Regents of the University of California. 003 * All rights reserved. 004 * 005 * '$Author: crawl $' 006 * '$Date: 2015-08-24 22:49:10 +0000 (Mon, 24 Aug 2015) $' 007 * '$Revision: 33635 $' 008 * 009 * Permission is hereby granted, without written agreement and without 010 * license or royalty fees, to use, copy, modify, and distribute this 011 * software and its documentation for any purpose, provided that the above 012 * copyright notice and the following two paragraphs appear in all copies 013 * of this software. 014 * 015 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY 016 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 017 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF 018 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF 019 * SUCH DAMAGE. 020 * 021 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, 022 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 023 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE 024 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF 025 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, 026 * ENHANCEMENTS, OR MODIFICATIONS. 027 * 028 */ 029 030package org.kepler.data.conversion.binary; 031 032import java.nio.ByteBuffer; 033import java.util.Calendar; 034import java.util.TimeZone; 035 036import edu.hawaii.soest.kilonalu.adcp.Ensemble; 037import edu.hawaii.soest.kilonalu.adcp.EnsembleDataType; 038import ptolemy.actor.TypedAtomicActor; 039import ptolemy.actor.TypedIOPort; 040import ptolemy.data.ArrayToken; 041import ptolemy.data.BooleanToken; 042import ptolemy.data.DoubleToken; 043import ptolemy.data.FloatToken; 044import ptolemy.data.IntToken; 045import ptolemy.data.RecordToken; 046import ptolemy.data.Token; 047import ptolemy.data.expr.Parameter; 048import ptolemy.data.type.ArrayType; 049import ptolemy.data.type.BaseType; 050import ptolemy.data.type.RecordType; 051import ptolemy.data.type.Type; 052import ptolemy.kernel.CompositeEntity; 053import ptolemy.kernel.util.IllegalActionException; 054import ptolemy.kernel.util.NameDuplicationException; 055import ptolemy.kernel.util.Settable; 056 057/** 058 * @author Derik Barseghian Takes in a byte array representing an ensemble, 059 * converts it to an ensemble object, prints info from all the get 060 * methods the ensemble class offers, and then outputs the decoded 061 * numeric data (currently hardcoded to temperature, salinity, and 062 * pressure). using Chris Jones Ensemble code. 063 */ 064 065public class EnsembleActor extends TypedAtomicActor { 066 067 /** 068 * Construct a RBNBToKepler2 source with the given container and name. 069 * 070 * @param name 071 * The name of this actor. 072 * @exception IllegalActionException 073 * If the entity cannot be contained by the proposed 074 * container. 075 * @exception NameDuplicationException 076 * If the container already has an actor with this name. 077 */ 078 public EnsembleActor(CompositeEntity container, String name) 079 throws NameDuplicationException, IllegalActionException { 080 super(container, name); 081 082 // Set parameters. 083 numInputTokens = new Parameter(this, "numInputTokens"); 084 numInputTokens.setExpression("numStartTimes"); 085 086 arrayIO = new TypedIOPort(this, "data", true, false); 087 arrayIO.setTypeEquals(new ArrayType(new ArrayType( 088 BaseType.UNSIGNED_BYTE))); 089 arrayIO_tokenConsumptionRate = new Parameter(arrayIO, 090 "tokenConsumptionRate"); 091 arrayIO_tokenConsumptionRate.setExpression("numInputTokens"); 092 093 accept2dArrays = new Parameter(this, "accept2dArrays"); 094 accept2dArrays.setTypeEquals(BaseType.BOOLEAN); 095 accept2dArrays.setExpression("true"); 096 097 // hardcoded - not sure having an ensemble always means having temp, 098 // pressure and salinity: 099 tempIO = new TypedIOPort(this, "temperature", false, true); 100 pressureIO = new TypedIOPort(this, "pressure", false, true); 101 salinityIO = new TypedIOPort(this, "salinity", false, true); 102 systemPowerIO = new TypedIOPort(this, "systemPower", false, true); 103 104 outputArrayLength = new Parameter(this, "outputArrayLength"); 105 outputArrayLength.setExpression("(requestDuration+1)*numStartTimes"); // todo: 106 // this 107 // default 108 // is 109 // not 110 // generic 111 // obviously 112 outputArrayLength.setVisibility(Settable.FULL); 113 114 try { 115 Type[] types = new Type[labels.length]; 116 117 types[0] = new ArrayType(BaseType.DOUBLE); 118 types[1] = new ArrayType(BaseType.FLOAT); 119 RecordType rt = new RecordType(labels, types); 120 121 tempIO.setTypeEquals(rt); 122 pressureIO.setTypeEquals(rt); 123 124 types[1] = new ArrayType(BaseType.INT); 125 rt = new RecordType(labels, types); 126 salinityIO.setTypeEquals(rt); 127 rt = new RecordType(labels, types); 128 systemPowerIO.setTypeEquals(rt); 129 } catch (Exception e) { 130 System.out.println("" + e); 131 } 132 133 // RBNBurlInputParam = new Parameter(this, "RBNBurl", new 134 // StringToken(_server)); 135 136 // _sink = new Sink(); 137 138 _attachText("_iconDescription", "<svg>\n" + "<rect x=\"0\" y=\"0\" " 139 + "width=\"60\" height=\"20\" " + "style=\"fill:white\"/>\n" 140 + "</svg>\n"); 141 } 142 143 // ///////////////////////////////////////////////////////////////// 144 // // ports and parameters //// 145 146 public TypedIOPort arrayIO = null; 147 public TypedIOPort tempIO = null; 148 public TypedIOPort pressureIO = null; 149 public TypedIOPort salinityIO = null; 150 public TypedIOPort systemPowerIO = null; 151 152 // the (max) size of output arrays (some datasource will contain gaps): 153 public Parameter outputArrayLength; 154 public Parameter numInputTokens; 155 public Parameter arrayIO_tokenConsumptionRate; 156 157 public Parameter accept2dArrays; 158 159 private byte[] byteArray = null; 160 private ByteBuffer ensembleBuffer = null; 161 public int itr = 0; 162 String[] labels = { "timestamps", "data" }; 163 public int maxArrayLength = 0; 164 private boolean take2dArrays = true; 165 166 // **************begin ensemble vars***************** 167 int ADCChannelFive; 168 int ADCChannelFour; 169 int ADCChannelOne; 170 int ADCChannelSeven; 171 int ADCChannelSix; 172 int ADCChannelThree; 173 int ADCChannelTwo; 174 int ADCChannelZero; 175 int baseFrequencyIndex; 176 int beamAngle; 177 int beamDirection; 178 int beamPattern; 179 int binOneDistance; 180 int blankAfterTransmit; 181 int builtInTestResult; 182 // 183 int checksum; 184 int coordinateTransformParams; 185 int cpuFirmwareRevision; 186 int cpuFirmwareVersion; 187 int dataTypeID = 0x7f7f; // EnsembleDataType.HEADER 188 EnsembleDataType ensembleDataType; 189 // prob: 190 int dataTypeNumber; 191 float dataTypeOffset; 192 int depthCellLength; 193 float depthOfTransducer; 194 int ensembleNumber; 195 int ensembleNumberIncrement; 196 int errorStatusWord; 197 int errorVelocityThreshold; 198 int falseTargetThreshold; 199 int fixedLeaderID; 200 int fixedLeaderSpare; 201 202 // prob: 203 // int headerID; 204 205 int headerSpare; 206 float heading; 207 // prob: 208 // float headingAlignment; 209 // prob: 210 // float headingBias; 211 float headingStandardDeviation; 212 int lagLength; 213 int lowCorrelationThreshold; 214 int minPrePingWaitHundredths; 215 int minPrePingWaitMinutes; 216 int minPrePingWaitSeconds; 217 int numberOfBeams; 218 int numberOfBytesInEnsemble; 219 int numberOfCells; 220 int numberOfCodeRepetitions; 221 int numberOfDataTypes; 222 int pdRealOrSimulatedFlag; 223 int percentGoodMinimum; 224 int pingHundredths; 225 int pingMinutes; 226 int pingSeconds; 227 int pingsPerEnsemble; 228 float pitch; 229 float pitchStandardDeviation; 230 float pressure; 231 float pressureVariance; 232 int profilingMode; 233 int realTimeClockDay; 234 int realTimeClockHour; 235 int realTimeClockHundredths; 236 int realTimeClockMinute; 237 int realTimeClockMonth; 238 int realTimeClockSecond; 239 int realTimeClockYear; 240 int realTimeY2KClockCentury; 241 int realTimeY2KClockDay; 242 int realTimeY2KClockHour; 243 int realTimeY2KClockHundredths; 244 int realTimeY2KClockMinute; 245 int realTimeY2KClockMonth; 246 int realTimeY2KClockSecond; 247 int realTimeY2KClockYear; 248 int referenceLayerEnd; 249 int referenceLayerStart; 250 int reservedBIT; 251 float roll; 252 float rollStandardDeviation; 253 int salinity; 254 int sensorAvailability; 255 int sensorConfiguration; 256 int sensorDepthSetting; 257 int sensorHeadingSetting; 258 int sensorPitchSetting; 259 int sensorRollSetting; 260 int sensorSalinitySetting; 261 int sensorSource; 262 int sensorSpeedOfSoundSetting; 263 int sensorTemperatureSetting; 264 int serialNumber; 265 int signalProcessingMode; 266 int spareFieldOne; 267 int spareFieldTwo; 268 int speedOfSound; 269 int systemBandwidth; 270 int systemConfiguration; 271 int systemFrequency; 272 int systemPower; 273 float temperature; 274 int transducerAttachment; 275 int transformBinMappingSetting; 276 int transformThreeBeamSetting; 277 int transformTiltsSetting; 278 int transmitLagDistance; 279 int transmitPulseLength; 280 // protected int VariableLeaderID; 281 boolean isValid; 282 283 // **************end ensemble vars***************** 284 285 // ///////////////////////////////////////////////////////////////// 286 // // public methods //// 287 288 public void fire() throws IllegalActionException { 289 System.out 290 .println("derik ensembleactor debug. arrayIO_tokenConsumptionRate:" 291 + arrayIO_tokenConsumptionRate.getValueAsString()); 292 super.fire(); 293 294 take2dArrays = ((BooleanToken) accept2dArrays.getToken()) 295 .booleanValue(); 296 297 ArrayToken atInput; 298 ArrayToken token; 299 int numValid = 0; 300 int numInvalid = 0; 301 Token[] dataValues = new Token[labels.length]; 302 RecordToken recToken = null; 303 304 if (take2dArrays) { 305 System.out.println("take2dArray mode"); 306 // this can be set to (requestDuration+1)*numStartTimes 307 // (though there seems to be a bug at the moment where we're not 308 // getting the +1 w/ the binary chan) 309 maxArrayLength = ((IntToken) outputArrayLength.getToken()) 310 .intValue(); 311 System.out.println("maxArrayLength: " + maxArrayLength); 312 313 DoubleToken timeTokens[] = new DoubleToken[maxArrayLength]; 314 Token tempTokens[] = new Token[maxArrayLength]; 315 Token pressureTokens[] = new Token[maxArrayLength]; 316 Token salinityTokens[] = new Token[maxArrayLength]; 317 Token systemPowerTokens[] = new Token[maxArrayLength]; 318 319 boolean allNils = true; 320 321 boolean thisItrIsNil; 322 while (arrayIO.hasToken(0)) { 323 thisItrIsNil = true; // we'll check 324 // numValid = 0; 325 token = (ArrayToken) arrayIO.get(0); 326 // System.out.println("EnsembleActor got a token on arrayIO. token.length: " 327 // + token.length()); 328 329 // if *all* are nil, output nils 330 for (int j = 0; j < token.length(); j++) { 331 atInput = (ArrayToken) token.getElement(j); 332 // System.out.print("derik tmp debug atInput.toString:" + 333 // atInput.toString()); 334 335 if (atInput.isNil() 336 || atInput.toString().equalsIgnoreCase("nil") 337 || ((atInput.length() == 1) && (atInput.getElement( 338 0).toString().equalsIgnoreCase("nil")))) { 339 System.out.println("EnsembleActor got a nil token"); 340 } else { 341 thisItrIsNil = false; 342 allNils = false; 343 } 344 } 345 346 if (!thisItrIsNil) { 347 for (int j = 0; j < token.length(); j++) { 348 atInput = (ArrayToken) token.getElement(j); 349 350 // convert token to java type 351 byteArray = ArrayToken 352 .arrayTokenToUnsignedByteArray(atInput); 353 354 ensembleBuffer = ByteBuffer.allocate(byteArray.length); 355 ensembleBuffer.put(byteArray); 356 357 Ensemble en = new Ensemble(ensembleBuffer); 358 359 setVars(en); 360 // printDebug(); 361 362 if (!isValid) { 363 numInvalid++; 364 } else { 365 double time = getEnsembleDate(en); 366 367 tempTokens[numValid] = new FloatToken(temperature); 368 pressureTokens[numValid] = new FloatToken(pressure); 369 salinityTokens[numValid] = new IntToken(salinity); 370 systemPowerTokens[numValid] = new IntToken( 371 systemPower); 372 timeTokens[numValid] = new DoubleToken(time); 373 374 numValid++; 375 376 if (numValid >= maxArrayLength) { 377 System.out 378 .println("ERROR length exceeds hardcoded array max length in EnsembleActor.java"); 379 } 380 } 381 } 382 } 383 // } 384 }// end while 385 386 System.out 387 .println("num valid ensembles (actual output array length):" 388 + numValid 389 + "\nnum Invalid ensembles:" 390 + numInvalid); 391 392 if (allNils) { 393 System.out 394 .println("All tokens received were nil, outputtings nils"); 395 Token[] nilTokenArray = new Token[1]; 396 nilTokenArray[0] = Token.NIL; 397 ArrayToken nilArrayToken = new ArrayToken(nilTokenArray); 398 399 dataValues[0] = nilArrayToken; 400 dataValues[1] = nilArrayToken; 401 recToken = new RecordToken(labels, dataValues); 402 System.out 403 .println("EnsembleActor sending NILS out ports.\n***"); 404 tempIO.send(0, recToken); 405 pressureIO.send(0, recToken); 406 salinityIO.send(0, recToken); 407 systemPowerIO.send(0, recToken); 408 409 } 410 411 if (numValid > 0) { 412 Token actualLengthTempTokens[] = new Token[numValid]; 413 Token actualLengthPressureTokens[] = new Token[numValid]; 414 Token actualLengthSalinityTokens[] = new Token[numValid]; 415 Token actualLengthSystemPowerTokens[] = new Token[numValid]; 416 DoubleToken actualLengthTimeTokens[] = new DoubleToken[numValid]; 417 418 for (int i = 0; i < numValid; i++) { 419 actualLengthTempTokens[i] = tempTokens[i]; 420 actualLengthPressureTokens[i] = pressureTokens[i]; 421 actualLengthSalinityTokens[i] = salinityTokens[i]; 422 actualLengthSystemPowerTokens[i] = systemPowerTokens[i]; 423 actualLengthTimeTokens[i] = timeTokens[i]; 424 } 425 426 ArrayToken atTimeTokens = new ArrayToken(actualLengthTimeTokens); 427 ArrayToken atTempTokens = new ArrayToken(actualLengthTempTokens); 428 ArrayToken atPressureTokens = new ArrayToken( 429 actualLengthPressureTokens); 430 ArrayToken atSalinityTokens = new ArrayToken( 431 actualLengthSalinityTokens); 432 ArrayToken atSystemPowerTokens = new ArrayToken( 433 actualLengthSystemPowerTokens); 434 435 dataValues[0] = atTimeTokens; 436 dataValues[1] = atTempTokens; 437 recToken = new RecordToken(labels, dataValues); 438 System.out.println("EnsembleActor sending out ports.\n***"); 439 tempIO.send(0, recToken); 440 441 dataValues[1] = atPressureTokens; 442 recToken = new RecordToken(labels, dataValues); 443 pressureIO.send(0, recToken); 444 445 dataValues[1] = atSalinityTokens; 446 recToken = new RecordToken(labels, dataValues); 447 salinityIO.send(0, recToken); 448 449 dataValues[1] = atSystemPowerTokens; 450 recToken = new RecordToken(labels, dataValues); 451 systemPowerIO.send(0, recToken); 452 } 453 } else { // if not 2dArrays (ie 1 1d Ensemble at a time) 454 System.out.println("per-Ensemble mode"); 455 456 while (arrayIO.hasToken(0)) { 457 token = (ArrayToken) arrayIO.get(0); 458 459 Token[] testTokens = token.arrayValue(); 460 for (int i = 0; i < testTokens.length; i++) { 461 if (token.isNil() 462 || testTokens[i].toString().equalsIgnoreCase("nil")) { 463 System.out 464 .println("EnsembleActor got a nil token, outputting nil tokens"); 465 dataValues[0] = Token.NIL; 466 dataValues[1] = Token.NIL; 467 recToken = new RecordToken(labels, dataValues); 468 tempIO.send(0, recToken); 469 pressureIO.send(0, recToken); 470 salinityIO.send(0, recToken); 471 systemPowerIO.send(0, recToken); 472 } else { 473 474 // convert token to java type 475 byteArray = ArrayToken 476 .arrayTokenToUnsignedByteArray(token); 477 478 ensembleBuffer = ByteBuffer.allocate(byteArray.length); 479 ensembleBuffer.put(byteArray); 480 Ensemble en = new Ensemble(ensembleBuffer); 481 482 setVars(en); 483 484 double time = getEnsembleDate(en); 485 486 if (en.isValid()) { 487 488 dataValues[0] = new DoubleToken(time); 489 dataValues[1] = new FloatToken(temperature); 490 recToken = new RecordToken(labels, dataValues); 491 tempIO.send(0, recToken); 492 493 dataValues[1] = new FloatToken(pressure); 494 recToken = new RecordToken(labels, dataValues); 495 pressureIO.send(0, recToken); 496 497 dataValues[1] = new IntToken(salinity); 498 recToken = new RecordToken(labels, dataValues); 499 salinityIO.send(0, recToken); 500 501 dataValues[1] = new IntToken(systemPower); 502 recToken = new RecordToken(labels, dataValues); 503 systemPowerIO.send(0, recToken); 504 } 505 } 506 } 507 } 508 } 509 510 // postfire(); 511 }// fire 512 513 public double getEnsembleDate(Ensemble en) { 514 515 double time = 0; 516 517 int ensYear = (en.getRealTimeY2KClockCentury() * 100) 518 + en.getRealTimeY2KClockYear(); 519 int ensMonth = en.getRealTimeY2KClockMonth() - 1; // 0 start 520 int ensDay = en.getRealTimeY2KClockDay(); 521 int ensHour = en.getRealTimeY2KClockHour(); 522 int ensMinute = en.getRealTimeY2KClockMinute(); 523 int ensSecond = en.getRealTimeY2KClockSecond(); 524 int ensHundredths = en.getRealTimeY2KClockHundredths(); 525 526 Calendar ensCalendar = Calendar 527 .getInstance(TimeZone.getTimeZone("GMT")); 528 ensCalendar.set(ensYear, ensMonth, ensDay, ensHour, ensMinute, 529 ensSecond); 530 ensCalendar.add(Calendar.MILLISECOND, ensHundredths * 10); 531 time = (double) ensCalendar.getTime().getTime(); 532 533 // System.out.println("ensCalendar:" +ensCalendar.getTime().toString() + 534 // " time:" + time); 535 return time; 536 } 537 538 public void setVars(Ensemble en) { 539 540 ADCChannelFive = en.getADCChannelFive(); 541 ADCChannelFour = en.getADCChannelFour(); 542 ADCChannelOne = en.getADCChannelOne(); 543 ADCChannelSeven = en.getADCChannelSeven(); 544 ADCChannelSix = en.getADCChannelSix(); 545 ADCChannelThree = en.getADCChannelThree(); 546 ADCChannelTwo = en.getADCChannelTwo(); 547 ADCChannelZero = en.getADCChannelZero(); 548 baseFrequencyIndex = en.getBaseFrequencyIndex(); 549 beamAngle = en.getBeamAngle(); 550 beamDirection = en.getBeamDirection(); 551 beamPattern = en.getBeamPattern(); 552 binOneDistance = en.getBinOneDistance(); 553 blankAfterTransmit = en.getBlankAfterTransmit(); 554 builtInTestResult = en.getBuiltInTestResult(); 555 // 556 checksum = en.getChecksum(); 557 coordinateTransformParams = en.getCoordinateTransformParams(); 558 cpuFirmwareRevision = en.getCpuFirmwareRevision(); 559 cpuFirmwareVersion = en.getCpuFirmwareVersion(); 560 dataTypeID = 0x7f7f; // EnsembleDataType.HEADER 561 ensembleDataType = en.getDataType(dataTypeID); 562 // prob: 563 // dataTypeNumber = en.getDataTypeNumber(ensembleDataType); 564 // dataTypeOffset = en.getDataTypeOffset(dataTypeNumber); 565 depthCellLength = en.getDepthCellLength(); 566 depthOfTransducer = en.getDepthOfTransducer(); 567 ensembleNumber = en.getEnsembleNumber(); 568 ensembleNumberIncrement = en.getEnsembleNumberIncrement(); 569 errorStatusWord = en.getErrorStatusWord(); 570 errorVelocityThreshold = en.getErrorVelocityThreshold(); 571 falseTargetThreshold = en.getFalseTargetThreshold(); 572 fixedLeaderID = en.getFixedLeaderID(); 573 fixedLeaderSpare = en.getFixedLeaderSpare(); 574 575 // prob: 576 // int headerID = en.getHeaderID(); 577 578 headerSpare = en.getHeaderSpare(); 579 heading = en.getHeading(); 580 // prob: 581 // float headingAlignment = en.getHeadingAlignment(); 582 // prob: 583 // float headingBias = en.getHeadingBias(); 584 headingStandardDeviation = en.getHeadingStandardDeviation(); 585 lagLength = en.getLagLength(); 586 lowCorrelationThreshold = en.getLowCorrelationThreshold(); 587 minPrePingWaitHundredths = en.getMinPrePingWaitHundredths(); 588 minPrePingWaitMinutes = en.getMinPrePingWaitMinutes(); 589 minPrePingWaitSeconds = en.getMinPrePingWaitSeconds(); 590 numberOfBeams = en.getNumberOfBeams(); 591 numberOfBytesInEnsemble = en.getNumberOfBytesInEnsemble(); 592 numberOfCells = en.getNumberOfCells(); 593 numberOfCodeRepetitions = en.getNumberOfCodeRepetitions(); 594 numberOfDataTypes = en.getNumberOfDataTypes(); 595 pdRealOrSimulatedFlag = en.getPdRealOrSimulatedFlag(); 596 percentGoodMinimum = en.getPercentGoodMinimum(); 597 pingHundredths = en.getPingHundredths(); 598 pingMinutes = en.getPingMinutes(); 599 pingSeconds = en.getPingSeconds(); 600 pingsPerEnsemble = en.getPingsPerEnsemble(); 601 pitch = en.getPitch(); 602 pitchStandardDeviation = en.getPitchStandardDeviation(); 603 pressure = en.getPressure(); 604 pressureVariance = en.getPressureVariance(); 605 profilingMode = en.getProfilingMode(); 606 realTimeClockDay = en.getRealTimeClockDay(); 607 realTimeClockHour = en.getRealTimeClockHour(); 608 realTimeClockHundredths = en.getRealTimeClockHundredths(); 609 realTimeClockMinute = en.getRealTimeClockMinute(); 610 realTimeClockMonth = en.getRealTimeClockMonth(); 611 realTimeClockSecond = en.getRealTimeClockSecond(); 612 realTimeClockYear = en.getRealTimeClockYear(); 613 realTimeY2KClockCentury = en.getRealTimeY2KClockCentury(); 614 realTimeY2KClockDay = en.getRealTimeY2KClockDay(); 615 realTimeY2KClockHour = en.getRealTimeY2KClockHour(); 616 realTimeY2KClockHundredths = en.getRealTimeY2KClockHundredths(); 617 realTimeY2KClockMinute = en.getRealTimeY2KClockMinute(); 618 realTimeY2KClockMonth = en.getRealTimeY2KClockMonth(); 619 realTimeY2KClockSecond = en.getRealTimeY2KClockSecond(); 620 realTimeY2KClockYear = en.getRealTimeY2KClockYear(); 621 referenceLayerEnd = en.getReferenceLayerEnd(); 622 referenceLayerStart = en.getReferenceLayerStart(); 623 reservedBIT = en.getReservedBIT(); 624 roll = en.getRoll(); 625 rollStandardDeviation = en.getRollStandardDeviation(); 626 salinity = en.getSalinity(); 627 sensorAvailability = en.getSensorAvailability(); 628 sensorConfiguration = en.getSensorConfiguration(); 629 sensorDepthSetting = en.getSensorDepthSetting(); 630 sensorHeadingSetting = en.getSensorHeadingSetting(); 631 sensorPitchSetting = en.getSensorPitchSetting(); 632 sensorRollSetting = en.getSensorRollSetting(); 633 sensorSalinitySetting = en.getSensorSalinitySetting(); 634 sensorSource = en.getSensorSource(); 635 sensorSpeedOfSoundSetting = en.getSensorSpeedOfSoundSetting(); 636 sensorTemperatureSetting = en.getSensorTemperatureSetting(); 637 serialNumber = en.getSerialNumber(); 638 signalProcessingMode = en.getSignalProcessingMode(); 639 spareFieldOne = en.getSpareFieldOne(); 640 spareFieldTwo = en.getSpareFieldTwo(); 641 speedOfSound = en.getSpeedOfSound(); 642 systemBandwidth = en.getSystemBandwidth(); 643 systemConfiguration = en.getSystemConfiguration(); 644 systemFrequency = en.getSystemFrequency(); 645 systemPower = en.getSystemPower(); 646 temperature = en.getTemperature(); 647 transducerAttachment = en.getTransducerAttachment(); 648 transformBinMappingSetting = en.getTransformBinMappingSetting(); 649 transformThreeBeamSetting = en.getTransformThreeBeamSetting(); 650 transformTiltsSetting = en.getTransformTiltsSetting(); 651 transmitLagDistance = en.getTransmitLagDistance(); 652 transmitPulseLength = en.getTransmitPulseLength(); 653 // VariableLeaderID = en.getVariableLeaderID(); 654 isValid = en.isValid(); 655 656 } 657 658 public void printDebug() { 659 660 System.out.println("ADCChannelFive: " + ADCChannelFive); 661 System.out.println("ADCChannelFour: " + ADCChannelFour); 662 System.out.println("ADCChannelOne: " + ADCChannelOne); 663 System.out.println("ADCChannelSeven: " + ADCChannelSeven); 664 System.out.println("ADCChannelSix: " + ADCChannelSix); 665 System.out.println("ADCChannelThree: " + ADCChannelThree); 666 System.out.println("ADCChannelTwo: " + ADCChannelTwo); 667 System.out.println("ADCChannelZero: " + ADCChannelZero); 668 System.out.println("baseFrequencyIndex: " + baseFrequencyIndex); 669 System.out.println("beamAngle: " + beamAngle); 670 System.out.println("beamDirection: " + beamDirection); 671 System.out.println("beamPattern: " + beamPattern); 672 System.out.println("binOneDistance: " + binOneDistance); 673 System.out.println("blankAfterTransmit: " + blankAfterTransmit); 674 System.out.println("builtInTestResult: " + builtInTestResult); 675 System.out.println("checksum: " + checksum); 676 System.out.println("coordinateTransformParams: " 677 + coordinateTransformParams); 678 System.out.println("cpuFirmwareRevision: " + cpuFirmwareRevision); 679 System.out.println("cpuFirmwareVersion: " + cpuFirmwareVersion); 680 // System.out.println("dataTypeNumber: " + dataTypeNumber); 681 // System.out.println("dataTypeOffset: " + dataTypeOffset); 682 System.out.println("depthCellLength: " + depthCellLength); 683 System.out.println("depthOfTransducer: " + depthOfTransducer); 684 System.out.println("ensembleNumber: " + ensembleNumber); 685 System.out.println("ensembleNumberIncrement: " 686 + ensembleNumberIncrement); 687 System.out.println("errorStatusWord: " + errorStatusWord); 688 System.out.println("errorVelocityThreshold: " + errorVelocityThreshold); 689 System.out.println("falseTargetThreshold: " + falseTargetThreshold); 690 System.out.println("fixedLeaderID: " + fixedLeaderID); 691 System.out.println("fixedLeaderSpare: " + fixedLeaderSpare); 692 // //some error with this get? 693 // System.out.println("headerID: " + headerID); 694 // System.out.println("headingAlignment: " + headingAlignment); 695 // System.out.println("headingBias: " + headingBias); 696 System.out.println("headerSpare: " + headerSpare); 697 System.out.println("heading: " + heading); 698 System.out.println("headingStandardDeviation: " 699 + headingStandardDeviation); 700 System.out.println("lagLength: " + lagLength); 701 System.out.println("lowCorrelationThreshold: " 702 + lowCorrelationThreshold); 703 System.out.println("minPrePingWaitHundredths: " 704 + minPrePingWaitHundredths); 705 System.out.println("minPrePingWaitMinutes: " + minPrePingWaitMinutes); 706 System.out.println("minPrePingWaitSeconds: " + minPrePingWaitSeconds); 707 System.out.println("numberOfBeams: " + numberOfBeams); 708 System.out.println("numberOfBytesInEnsemble: " 709 + numberOfBytesInEnsemble); 710 System.out.println("numberOfCells: " + numberOfCells); 711 System.out.println("numberOfCodeRepetitions: " 712 + numberOfCodeRepetitions); 713 System.out.println("numberOfDataTypes: " + numberOfDataTypes); 714 System.out.println("pdRealOrSimulatedFlag: " + pdRealOrSimulatedFlag); 715 System.out.println("percentGoodMinimum: " + percentGoodMinimum); 716 System.out.println("pingHundredths: " + pingHundredths); 717 System.out.println("pingMinutes: " + pingMinutes); 718 System.out.println("pingSeconds: " + pingSeconds); 719 System.out.println("pingsPerEnsemble: " + pingsPerEnsemble); 720 System.out.println("pitch: " + pitch); 721 System.out.println("pitchStandardDeviation: " + pitchStandardDeviation); 722 System.out.println("pressure: " + pressure); 723 System.out.println("pressureVariance: " + pressureVariance); 724 System.out.println("profilingMode: " + profilingMode); 725 System.out.println("realTimeClockDay: " + realTimeClockDay); 726 System.out.println("realTimeClockHour: " + realTimeClockHour); 727 System.out.println("realTimeClockHundredths: " 728 + realTimeClockHundredths); 729 System.out.println("realTimeClockMinute: " + realTimeClockMinute); 730 System.out.println("realTimeClockMonth: " + realTimeClockMonth); 731 System.out.println("realTimeClockSecond: " + realTimeClockSecond); 732 System.out.println("realTimeClockYear: " + realTimeClockYear); 733 System.out.println("realTimeY2KClockCentury: " 734 + realTimeY2KClockCentury); 735 System.out.println("realTimeY2KClockDay: " + realTimeY2KClockDay); 736 System.out.println("realTimeY2KClockHour: " + realTimeY2KClockHour); 737 System.out.println("realTimeY2KClockHundredths: " 738 + realTimeY2KClockHundredths); 739 System.out.println("realTimeY2KClockMinute: " + realTimeY2KClockMinute); 740 System.out.println("realTimeY2KClockMonth: " + realTimeY2KClockMonth); 741 System.out.println("realTimeY2KClockSecond: " + realTimeY2KClockSecond); 742 System.out.println("realTimeY2KClockYear: " + realTimeY2KClockYear); 743 System.out.println("referenceLayerEnd: " + referenceLayerEnd); 744 System.out.println("referenceLayerStart: " + referenceLayerStart); 745 System.out.println("reservedBIT: " + reservedBIT); 746 System.out.println("roll: " + roll); 747 System.out.println("rollStandardDeviation: " + rollStandardDeviation); 748 System.out.println("salinity: " + salinity); 749 System.out.println("sensorAvailability: " + sensorAvailability); 750 System.out.println("sensorConfiguration: " + sensorConfiguration); 751 System.out.println("sensorDepthSetting: " + sensorDepthSetting); 752 System.out.println("sensorHeadingSetting: " + sensorHeadingSetting); 753 System.out.println("sensorPitchSetting: " + sensorPitchSetting); 754 System.out.println("sensorRollSetting: " + sensorRollSetting); 755 System.out.println("sensorSalinitySetting: " + sensorSalinitySetting); 756 System.out.println("sensorSource: " + sensorSource); 757 System.out.println("sensorSpeedOfSoundSetting: " 758 + sensorSpeedOfSoundSetting); 759 System.out.println("sensorTemperatureSetting: " 760 + sensorTemperatureSetting); 761 System.out.println("serialNumber: " + serialNumber); 762 System.out.println("signalProcessingMode: " + signalProcessingMode); 763 System.out.println("spareFieldOne: " + spareFieldOne); 764 System.out.println("spareFieldTwo: " + spareFieldTwo); 765 System.out.println("speedOfSound: " + speedOfSound); 766 System.out.println("systemBandwidth: " + systemBandwidth); 767 System.out.println("systemConfiguration: " + systemConfiguration); 768 System.out.println("systemFrequency: " + systemFrequency); 769 System.out.println("systemPower: " + systemPower); 770 System.out.println("temperature: " + temperature); 771 System.out.println("transducerAttachment: " + transducerAttachment); 772 System.out.println("transformBinMappingSetting: " 773 + transformBinMappingSetting); 774 System.out.println("transformThreeBeamSetting: " 775 + transformThreeBeamSetting); 776 System.out.println("transformTiltsSetting: " + transformTiltsSetting); 777 System.out.println("transmitLagDistance: " + transmitLagDistance); 778 System.out.println("transmitPulseLength: " + transmitPulseLength); 779 System.out.println("isValid: " + isValid); 780 } 781 782 public void attributeChanged(ptolemy.kernel.util.Attribute attribute) 783 throws ptolemy.kernel.util.IllegalActionException { 784 785 if (attribute == accept2dArrays) { 786 boolean tmpTake2dArrays = ((BooleanToken) accept2dArrays.getToken()) 787 .booleanValue(); 788 789 if (take2dArrays != tmpTake2dArrays) { 790 take2dArrays = tmpTake2dArrays; 791 setPortsFor2d(tmpTake2dArrays); 792 793 if (take2dArrays) { 794 numInputTokens.setExpression("numStartTimes"); 795 } else { 796 numInputTokens.setExpression("1"); 797 } 798 799 } 800 } 801 802 } 803 804 public void setPortsFor2d(boolean twoD) { 805 if (twoD) { 806 807 // input 808 arrayIO.setTypeEquals(new ArrayType(new ArrayType( 809 BaseType.UNSIGNED_BYTE))); 810 arrayIO_tokenConsumptionRate.setExpression("numInputTokens"); 811 arrayIO_tokenConsumptionRate.updateContent(); 812 813 // outputs 814 Type[] types = new Type[labels.length]; 815 816 types[0] = new ArrayType(BaseType.DOUBLE); 817 types[1] = new ArrayType(BaseType.FLOAT); 818 RecordType rt = new RecordType(labels, types); 819 820 tempIO.setTypeEquals(rt); 821 pressureIO.setTypeEquals(rt); 822 823 types[1] = new ArrayType(BaseType.INT); 824 rt = new RecordType(labels, types); 825 salinityIO.setTypeEquals(rt); 826 systemPowerIO.setTypeEquals(rt); 827 828 outputArrayLength 829 .setExpression("(requestDuration+1)*numStartTimes"); // todo: 830 // this 831 // default 832 // is 833 // not 834 // generic 835 // obviously 836 837 } else { 838 839 // input 840 arrayIO.setTypeEquals(new ArrayType(BaseType.UNSIGNED_BYTE)); 841 arrayIO_tokenConsumptionRate.setExpression("1"); 842 arrayIO_tokenConsumptionRate.updateContent(); 843 844 // outputs 845 Type[] types = new Type[labels.length]; 846 847 types[0] = BaseType.DOUBLE; 848 types[1] = BaseType.FLOAT; 849 RecordType rt = new RecordType(labels, types); 850 851 tempIO.setTypeEquals(rt); 852 pressureIO.setTypeEquals(rt); 853 854 types[1] = BaseType.INT; 855 rt = new RecordType(labels, types); 856 salinityIO.setTypeEquals(rt); 857 systemPowerIO.setTypeEquals(rt); 858 859 // this is just to avoid confusion, outputArrayLength is not used 860 // for per-Ensemble mode. 861 outputArrayLength.setExpression("0"); 862 863 } 864 } 865 866 /* 867 * Post fire the actor. Return false to indicated that the process has 868 * finished. If it returns true, the process will continue indefinitely. 869 */ 870 public boolean postfire() throws IllegalActionException { 871 872 return false; 873 } 874 875}// EnsembleActor.java