1 import java.io._
   2 import java.nio.ByteBuffer
   3 
   4 import scala.collection.mutable.ListBuffer
   5 
   6 object Hello_mdf {
   7 
   8   def main(args: Array[String]) {
   9     var datFile = "D:\\Scala\\Dat\\00006004_251-4416EN12-ECU FI 0_1212_Knock and Pre-ignition control check on vehicle (Dynamic and diagnosis)_cold start 30C_tianmashan_00006004_2018-10-17_09-10-11_2018-10-17_09-21-22_sorted.dat";
  10     var fis = new FileInputStream(new File(datFile))
  11     val bytes = new Array[Byte](fis.available().toInt)
  12     fis.read(bytes)
  13     fis.close()
  14 
  15     var mdf = new MDF(bytes)
  16 
  17     var dict: Map[String, Channel] = Map()
  18     var channelTmep = new Channel;
  19     
  20     channelTmep = mdf.get("DFES_ctEntry")
  21     if(channelTmep == null)
  22       println("Signal is not found")
  23     else
  24       dict += ("DFES_ctEntry" -> mdf.get("DFES_ctEntry"))
  25 
  26     channelTmep = mdf.get("nmot_w")
  27     if(channelTmep == null)
  28       println("Signal is not found")
  29     else
  30       dict += ("nmot_w" -> mdf.get("nmot_w"))
  31 
  32     channelTmep = mdf.get("rl_w")
  33     if(channelTmep == null)
  34       println("Signal is not found")
  35     else
  36       dict += ("rl_w" -> mdf.get("rl_w"))
  37 
  38     channelTmep = mdf.get("EpmCaS_phiCaSOfsAvg_[0]")
  39     if(channelTmep == null)
  40       println("Signal is not found")
  41     else
  42       dict += ("EpmCaS_phiCaSOfsAvg_[0]" -> mdf.get("EpmCaS_phiCaSOfsAvg_[0]"))
  43     channelTmep = mdf.get("EpmCaS_phiCaSOfsAvg_[1]")
  44     if(channelTmep == null)
  45       println("Signal is not found")
  46     else
  47       dict += ("EpmCaS_phiCaSOfsAvg_[1]" -> mdf.get("EpmCaS_phiCaSOfsAvg_[1]"))
  48 
  49     channelTmep = mdf.get("fkmsdk_w")
  50     if(channelTmep == null)
  51       println("Signal is not found")
  52     else
  53       dict += ("fkmsdk_w" -> mdf.get("fkmsdk_w")) // 节气门自学习
  54 
  55     channelTmep = mdf.get("fra_w")
  56     if(channelTmep == null)
  57       println("Signal is not found")
  58     else
  59       dict += ("fra_w" -> mdf.get("fra_w"))
  60 
  61     channelTmep = mdf.get("uprm_w")
  62     if(channelTmep == null)
  63       println("Signal is not found")
  64     else
  65       dict += ("uprm_w" -> mdf.get("uprm_w"))
  66 
  67     channelTmep = mdf.get("MoF_rTrqInrAct")
  68     if(channelTmep == null)
  69       println("Signal is not found")
  70     else
  71       dict += ("MoF_rTrqInrAct" -> mdf.get("MoF_rTrqInrAct"))
  72 
  73     channelTmep = mdf.get("miist_w")
  74     if(channelTmep == null)
  75       println("Signal is not found")
  76     else
  77       dict += ("miist_w" -> mdf.get("miist_w"))
  78 
  79     channelTmep = mdf.get("rkrnv6_w_[0]")
  80     if(channelTmep == null)
  81       println("Signal is not found")
  82     else
  83       dict += ("rkrnv6_w_[0]" -> mdf.get("rkrnv6_w_[0]"))
  84     channelTmep = mdf.get("rkrnv6_w_[1]")
  85     if(channelTmep == null)
  86       println("Signal is not found")
  87     else
  88       dict += ("rkrnv6_w_[1]" -> mdf.get("rkrnv6_w_[1]"))
  89     channelTmep = mdf.get("rkrnv6_w_[2]")
  90     if(channelTmep == null)
  91       println("Signal is not found")
  92     else
  93     dict += ("rkrnv6_w_[2]" -> mdf.get("rkrnv6_w_[2]"))
  94     channelTmep = mdf.get("rkrnv6_w_[3]")
  95     if(channelTmep == null)
  96       println("Signal is not found")
  97     else
  98       dict += ("rkrnv6_w_[3]" -> mdf.get("rkrnv6_w_[3]"))
  99 
 100     channelTmep = mdf.get("B_kl")
 101     if(channelTmep == null)
 102       println("Signal is not found")
 103     else
 104       dict += ("B_kl" -> mdf.get("B_kl"))
 105 
 106 
 107     dict.keys.foreach {
 108       i => {
 109         println("*************" + i + "*******************")
 110         for (j <- 0 until 30) {
 111           println("Count: "+ j, " time: "+dict(i).time(j), " data: "+dict(i).data(j))
 112         }
 113         println("*****************************************")
 114       }
 115     }
 116 
 117     // make fault counter
 118     var faultCounter = makeEmptySeries(dict("nmot_w"))
 119 
 120     // var dict_nmotrl = p1
 121     var nmotSeries =makeSeries(dict("nmot_w"))
 122     var rlSeries =makeSeries(dict("rl_w"))
 123     var nmotRlSeries = makeXYSeries(dict("nmot_w"), dict("rl_w"))
 124     // epm
 125     var epm0Series =makeSeries(dict("EpmCaS_phiCaSOfsAvg_[0]"))
 126     var epm1Series =makeSeries(dict("EpmCaS_phiCaSOfsAvg_[1]"))
 127 
 128     var (epm0StatisX, epm0StatisY)  =makeDistribution(-10,10, 30, dict("EpmCaS_phiCaSOfsAvg_[0]"))
 129     var (epm1StatisX, epm1StatisY)  =makeDistribution(-10,10, 30, dict("EpmCaS_phiCaSOfsAvg_[0]"))
 130     // throttle
 131     var fkmsdkSeries =makeSeries(dict("fkmsdk_w"))
 132     var (fkmsdkStatisX, fkmsdkStatisY)  =makeDistribution(-10,10, 30, dict("fkmsdk_w"))
 133     // lambda
 134     var lambdaSeries = makeSeries(dict("fra_w"))
 135     var (lambdaSeriesStatisX, lambdaSeriesStatisY) = makeDistribution(-10,10, 30, dict("fra_w"))
 136     // hdfs
 137     var uprmSeries = makeSeries(dict("uprm_w"))
 138     var (uprmSeriesStatisX, uprmSeriesStatisY)  =makeDistribution(-10,10, 30, dict("uprm_w"))
 139     // safetyTorque
 140     var minusArray = makeMinusSeries(dict("MoF_rTrqInrAct"), dict("miist_w"))
 141     var (minusArrayX, minusArrayY) = makeDistributionMinus(-10,10, 30, dict("MoF_rTrqInrAct"), dict("miist_w"))
 142     // knock OverView
 143     // Noise Ref
 144     var noiseRef0 = makeSeries(dict("rkrnv6_w_[0]"))
 145     var noiseRef1 = makeSeries(dict("rkrnv6_w_[1]"))
 146     var noiseRef2 = makeSeries(dict("rkrnv6_w_[2]"))
 147     var noiseRef3 = makeSeries(dict("rkrnv6_w_[3]"))
 148 
 149 //    println(epm0StatisY.mkString(","))
 150     println("--------------------------------------done--------------------------------------")
 151   }
 152 
 153   def makeEmptySeries(_channel: Channel): List[Array[Double]]={
 154 
 155     var _series= new ListBuffer[Array[Double]]
 156 
 157     for (i <- 0 until _channel.time.length) {
 158 
 159       var _arr = new Array[Double](2)
 160       _arr(0) = _channel.time(i)
 161       _arr(1) = 0.0
 162       _series.append(_arr)
 163     }
 164 
 165     _series.toList
 166   }
 167 
 168   def makeSeries(_channel: Channel): List[Array[Double]]={
 169 
 170     var _series= new ListBuffer[Array[Double]]
 171 
 172     for (i <- 0 until _channel.time.length) {
 173 
 174       var _arr = new Array[Double](2)
 175       _arr(0) = _channel.time(i)
 176       _arr(1) = _channel.data(i)
 177       _series.append(_arr)
 178     }
 179 
 180     _series.toList
 181   }
 182 
 183   def makeMinusSeries(_channel: Channel, _channel2: Channel): List[Array[Double]]={
 184 
 185     var _series= new ListBuffer[Array[Double]]
 186 
 187     for (i <- 0 until _channel.time.length) {
 188 
 189       var _arr = new Array[Double](2)
 190       _arr(0) = _channel.time(i)
 191       _arr(1) = _channel.data(i)-_channel2.data(i)
 192       _series.append(_arr)
 193     }
 194 
 195     _series.toList
 196   }
 197 
 198   def makeXYSeries(_channel: Channel, _channel2: Channel): List[Array[Double]]={
 199 
 200     var _series= new ListBuffer[Array[Double]]
 201 
 202     for (i <- 0 until _channel.time.length) {
 203 
 204       var _arr = new Array[Double](2)
 205       _arr(0) = _channel.data(i)
 206       _arr(1) = _channel2.data(i)
 207       _series.append(_arr)
 208     }
 209 
 210     _series.toList
 211   }
 212 
 213   def makeDistribution(_min:Double, _max:Double, _bin:Int, _chan: Channel)={
 214 
 215     var _seriesX = new Array[Double](_bin)
 216     var _seriesY = new Array[Double](_bin)
 217 
 218     var x_delta = (_max-_min)/(_bin-1)
 219 
 220     for(i<-0 until _bin-1){
 221       _seriesX(i) = _min+i*x_delta
 222     }
 223     _seriesX(_seriesX.length-1) = _max
 224 
 225     for(i<-0 until _chan.data.length){
 226       for (j<-0 until _bin){
 227         if(_chan.data(i)>_seriesX(j)-x_delta/2 & _chan.data(i)<=_seriesX(j)+x_delta/2){
 228           _seriesY(j)+=1
 229         }
 230       }
 231     }
 232 
 233     (_seriesX, _seriesY)
 234 
 235   }
 236 
 237   def makeDistributionMinus(_min:Double, _max:Double, _bin:Int, _chan: Channel, _chan2:Channel) ={
 238 
 239     var _seriesX = new Array[Double](_bin)
 240     var _seriesY = new Array[Double](_bin)
 241 
 242     var x_delta = (_max-_min)/(_bin-1)
 243 
 244     for(i<-0 until _bin-1){
 245       _seriesX(i) = _min+i*x_delta
 246     }
 247     _seriesX(_seriesX.length-1) = _max
 248 
 249     for(i<-0 until _chan.data.length){
 250       for (j<-0 until _bin){
 251         if((_chan.data(i)-_chan2.data(i))>_seriesX(j)-x_delta/2 & (_chan.data(i)-_chan2.data(i))<=_seriesX(j)+x_delta/2){
 252           _seriesY(j)+=1
 253         }
 254       }
 255     }
 256     (_seriesX, _seriesY)
 257   }
 258 
 259   class MDF {
 260 
 261     var allBytes: Array[Byte] = _
 262     var idBlock: IDBlock = _
 263     var hdBlock: HDBlock = _
 264     var dgBlocks: List[DGBlock] = _
 265 
 266     def this(_bytes: Array[Byte]) {
 267 
 268       this()
 269       this.allBytes = _bytes
 270       this.idBlock = new IDBlock(_bytes)
 271       this.hdBlock = new HDBlock(_bytes)
 272 
 273       this.dgBlocks = List()
 274       var dg = new DGBlock(_bytes, hdBlock.pointerFirstDGBlock)
 275       dgBlocks = dgBlocks :+ dg
 276       while (dg.pointerNextDGBlock != 0) {
 277         dg = new DGBlock(_bytes, dg.pointerNextDGBlock)
 278         dgBlocks = dgBlocks :+ dg
 279       }
 280     }
 281 
 282     def get(_channelName: String): Channel = {
 283 
 284       for {
 285         i <- 0 until this.dgBlocks.length
 286         j <- 0 until this.dgBlocks(i).cgBlocks.length
 287         k <- 0 until this.dgBlocks(i).cgBlocks(j).cnBlocks.length
 288       } {
 289 
 290                 /*println("i: "+i)
 291                 println("j: "+j)
 292                 println("k: "+k)*/
 293           
 294         var shortSignalName = this.dgBlocks(i).cgBlocks(j).cnBlocks(k).shortSignalName
 295         var index = 0
 296         if(shortSignalName.contains("\\")){
 297             index = shortSignalName.indexOf("\\")
 298             shortSignalName = shortSignalName.substring(0,index)
 299         }
 300         else  if(shortSignalName.contains(":")){
 301             index = shortSignalName.indexOf(":")
 302             shortSignalName = shortSignalName.substring(0,index)
 303         }
 304         
 305         if (shortSignalName.equals(_channelName)) {
 306 //          println("shortSignalName: "+this.dgBlocks(i).cgBlocks(j).cnBlocks(k).shortSignalName)
 307           var _channel = new Channel()
 308 
 309           _channel.idxCGBlock = j
 310 
 311           _channel.cCBlock = new CCBlock(this.allBytes, this.dgBlocks(i).cgBlocks(j).cnBlocks(k).pointerCCBlock)
 312 
 313           var numberOfRecord = this.dgBlocks(i).cgBlocks(j).numberRecords
 314           //          println("numberOfRecord", numberOfRecord)
 315 
 316           var recordSizeInByte = this.dgBlocks(i).cgBlocks(j).sizeDataRecord
 317           //          println("recordSizeInByte", recordSizeInByte)
 318 
 319           var pointerDataBlock = this.dgBlocks(i).pointerDataBlock
 320           //          println("pointerDataBlock", pointerDataBlock)
 321           
 322           var signalDataType = this.dgBlocks(i).cgBlocks(j).cnBlocks(k).signalDataType
 323           var signalDataType0 = this.dgBlocks(i).cgBlocks(j).cnBlocks(0).signalDataType
 324           //          println("signalDataType", signalDataType)
 325 
 326           var numberOfBits = this.dgBlocks(i).cgBlocks(j).cnBlocks(k).numberOfBits
 327           var numberOfBits0 = this.dgBlocks(i).cgBlocks(j).cnBlocks(0).numberOfBits
 328           //          println("numberOfBits", numberOfBits)
 329 
 330           var startOffsetInBits = this.dgBlocks(i).cgBlocks(j).cnBlocks(k).startOffsetInBits
 331           var startOffsetInBits0 = this.dgBlocks(i).cgBlocks(j).cnBlocks(0).startOffsetInBits
 332           //          println("startOffsetInBits", startOffsetInBits)
 333 
 334           var shortSignalName = this.dgBlocks(i).cgBlocks(j).cnBlocks(k).shortSignalName
 335           var shortSignalName0 = this.dgBlocks(i).cgBlocks(j).cnBlocks(0).shortSignalName
 336           //          println("shortSignalName", shortSignalName)
 337 
 338           var buffer = new Array[Byte](numberOfRecord * recordSizeInByte)
 339           for (i <- 0 until buffer.length) {
 340             // data block from dg
 341             buffer(i) = this.allBytes(i + pointerDataBlock)
 342           }
 343           
 344           var rawData = new Array[Double](numberOfRecord)
 345           //          println(this.dgBlocks(i).cgBlocks(j).cnBlocks(0).shortSignalName)  // get time channel signal name
 346           var rawTime = new Array[Double](numberOfRecord)
 347 
 348           signalDataType match {
 349             case 0 => {
 350               //              println("signalDataType",signalDataType)
 351               if (numberOfBits == 1) {
 352                 //                println("numberOfBits",numberOfBits)
 353                 rawData = DataReaderBit(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 354               }
 355 
 356               if (numberOfBits / 8 == 1) {
 357                 if (shortSignalName.contains("$")) {
 358                 }
 359                 else {
 360                   //                  println("numberOfBits",numberOfBits,"OK")
 361                   rawData = DataReaderBit(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 362                 }
 363               }
 364 
 365               if (numberOfBits / 8 == 2) {
 366                 //                println("numberOfBits",numberOfBits)
 367                 rawData = DataReaderUInt16(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 368               }
 369 
 370               if (numberOfBits / 8 == 4) {
 371                 //                println("numberOfBits",numberOfBits)
 372                 rawData = DataReaderUInt32(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 373               }
 374               if (numberOfBits0 / 8 == 8) {
 375                 //                println("8")
 376                 rawTime = DataReaderUInt64(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 377               }
 378             }
 379 
 380             case 1 => {
 381               println("signalDataType"+signalDataType)
 382               if (numberOfBits / 8 == 1) {
 383                 if (shortSignalName.contains("$")) {
 384                 }
 385                 else {
 386                   rawData = DataReaderBit(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 387                 }
 388               }
 389               if (numberOfBits / 8 == 2) {
 390                 rawData = DataReaderUInt16(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 391               }
 392               if (numberOfBits / 8 == 4) {
 393                 rawData = DataReaderUInt32(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 394               }
 395             }
 396 
 397             case 2 => {
 398               println("signalDataType"+signalDataType)
 399               if (numberOfBits / 8 == 4) {
 400                 rawData = DataReaderFloat(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 401               }
 402             }
 403 
 404             case 3 => {
 405               println("signalDataType"+signalDataType)
 406               rawData = DataReaderDouble(buffer, startOffsetInBits, numberOfRecord, recordSizeInByte)
 407             }
 408 
 409             case _ => {
 410               println("signalDataType Error")
 411             }
 412           }
 413 
 414           signalDataType0 match {
 415             case 0 => {
 416               if (numberOfBits0 == 1) {
 417                 //                println("1")
 418                 rawTime = DataReaderBit(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 419               }
 420 
 421               if (numberOfBits0 / 8 == 1) {
 422                 if (shortSignalName.contains("$")) {
 423                 }
 424                 else {
 425                   //                  println("2")
 426                   rawTime = DataReaderBit(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 427                 }
 428               }
 429 
 430               if (numberOfBits0 / 8 == 2) {
 431                 //                println("3")
 432                 rawTime = DataReaderUInt16(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 433               }
 434 
 435               if (numberOfBits0 / 8 == 4) {
 436                 //                println("4")
 437                 rawTime = DataReaderUInt32(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 438               }
 439               
 440               if (numberOfBits0 / 8 == 8) {
 441                 //                println("8")
 442                 rawTime = DataReaderUInt64(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 443               }
 444             }
 445 
 446             case 1 => {
 447               if (numberOfBits0 / 8 == 1) {
 448                 if (shortSignalName.contains("$")) {
 449                 }
 450                 else {
 451                   println("5")
 452                   rawTime = DataReaderBit(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 453                 }
 454               }
 455               if (numberOfBits0 / 8 == 2) {
 456                 println("6")
 457                 rawTime = DataReaderUInt16(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 458               }
 459               if (numberOfBits0 / 8 == 4) {
 460                 println("7")
 461                 rawTime = DataReaderUInt32(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 462               }
 463             }
 464 
 465             case 2 => {
 466               if (numberOfBits0 / 8 == 4) {
 467                 println("8")
 468                 rawTime = DataReaderFloat(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 469               }
 470 //              if (numberOfBits0 / 8 == 8) {
 471 //                //                println("4")
 472 //                rawTime = DataReaderUInt64(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 473 //              }
 474             }
 475 
 476             case 3 => {
 477               println("9","startOffset: "+startOffsetInBits0,"Record: " + numberOfRecord,"recordSize: "+recordSizeInByte)
 478               rawTime = DataReaderDouble(buffer, startOffsetInBits0, numberOfRecord, recordSizeInByte)
 479             }
 480             case _ => {
 481               println("signalDataType0")
 482             }
 483           }
 484 
 485           //      case 4 =>{println("lack of signal data type 4")}
 486           //      case 5 =>{println("lack of signal data type 5")}
 487           //      case 6 =>{println("lack of signal data type 6")}
 488           //      case 7 =>{
 489           //        // null
 490           //      }
 491           //      case 8 =>{println("lack of signal data type 8")}
 492           //      case 9 =>{println("lack of signal data type 9")}
 493           //      case 10 =>{println("lack of signal data type 10")}
 494           //      case 11 =>{println("lack of signal data type 11")}
 495           //      case 12 =>{println("lack of signal data type 12")}
 496           //      case 13 =>{println("lack of signal data type 13")}
 497           //      case 14 =>{println("lack of signal data type 14")}
 498           //      case 15 =>{println("lack of signal data type 15")}
 499           //      case 16 =>{println("lack of signal data type 16")}
 500           //
 501           //          println("_channel.cCBlock.conversionType",_channel.cCBlock.conversionType)
 502           //          println("_channel.cCBlock.sizeInformation",_channel.cCBlock.sizeInformation)
 503           //          println("_channel.cCBlock.p1",_channel.cCBlock.p1)
 504           //          println("_channel.cCBlock.p2",_channel.cCBlock.p2)
 505 
 506           _channel.cCBlock.conversionType match {
 507             case 0 => {
 508               if (_channel.cCBlock.sizeInformation > 0) {
 509                 for (i <- 0 until rawData.length) {
 510                   rawData(i) = _channel.cCBlock.p1 + _channel.cCBlock.p2 * rawData(i)
 511                 }
 512               }
 513             }
 514 
 515             case 1 => {
 516               println("lack of cc type 1")
 517             }
 518             case 2 => {
 519               println("lack of cc type 2")
 520             }
 521             case 6 => {
 522               println("lack of cc type 6")
 523             }
 524             case 7 => {
 525               println("lack of cc type 7")
 526             }
 527             case 8 => {
 528               println("lack of cc type 8")
 529             }
 530             case 9 => {
 531               println("lack of cc type 9")
 532             }
 533             case 10 => {
 534               println("lack of cc type 10")
 535             }
 536             case 11 => {
 537               //              println(this.dgBlocks(i).cgBlocks(j).cnBlocks(k).shortSignalName)
 538               println("lack of cc type 11")
 539             }
 540             case 12 => {
 541               println("lack of cc type 12")
 542             }
 543             case 132 => {
 544               println("lack of cc type 132")
 545             }
 546             case 133 => {
 547               println("lack of cc type 133")
 548             }
 549             case _ => {
 550 
 551             }
 552           }
 553 
 554           var time_cc = new CCBlock(this.allBytes, this.dgBlocks(i).cgBlocks(j).cnBlocks(0).pointerCCBlock)
 555           //          println("time_cc.conversionType", time_cc.conversionType)
 556           //          println("time_cc.sizeInformation", time_cc.sizeInformation)
 557           //          println("time_cc.p1", time_cc.p1)
 558           //          println("time_cc.p2", time_cc.p2)
 559 
 560           time_cc.conversionType match {
 561             case 0 => {
 562               if (time_cc.sizeInformation > 0) {
 563                 for (i <- 0 until rawTime.length) {
 564                   rawTime(i) = time_cc.p1 + time_cc.p2 * rawTime(i)
 565                 }
 566 
 567               }
 568             }
 569           }
 570 
 571           //          for(i<-0 until 1000){
 572           //            println("time", i, rawTime(i))
 573           //          }
 574           _channel.time = rawTime
 575           _channel.data = rawData
 576           return _channel
 577         }
 578       }
 579       return null
 580     }
 581   }
 582 
 583   class Channel {
 584     var arrayBuffer: Array[Byte] = _
 585 
 586     var channelName = ""
 587     var idxCGBlock = 0
 588     var cNBlock: CNBlock = _
 589     var cCBlock: CCBlock = _
 590     var time: Array[Double] = _
 591     var data: Array[Double] = _
 592 
 593   }
 594 
 595   class IDBlock(var _bytes: Array[Byte]) {
 596 
 597     var FileIdentifier = ""
 598     var formatIdentifier = ""
 599     var programIdentifier = ""
 600     var defaultByteOrder = 0
 601     var defaultFloatingPointFormat = 0
 602     var versionNumber = 0
 603 
 604     this.makeIDBlock()
 605 
 606     def makeIDBlock(): Unit = {
 607 
 608       var offset = 0
 609       var len = 8
 610       this.FileIdentifier = bytes2str(_bytes, offset, len)
 611       offset += len
 612 
 613       len = 8
 614       this.formatIdentifier = bytes2str(_bytes, offset, len)
 615       //      println("this.formatIdentifier", this.formatIdentifier)
 616       offset += len
 617 
 618       len = 8
 619       this.programIdentifier = bytes2str(_bytes, offset, len)
 620       offset += len
 621 
 622       len = 2
 623       this.defaultByteOrder = bytes2uint16(_bytes, offset)
 624       offset += len
 625 
 626       len = 2
 627       this.defaultFloatingPointFormat = bytes2uint16(_bytes, offset)
 628       offset += len
 629 
 630       len = 2
 631       this.versionNumber = bytes2uint16(_bytes, offset)
 632     }
 633   }
 634 
 635   class HDBlock(var _bytes: Array[Byte]) {
 636     var blockTypeIdentifier = ""
 637     var blockSize = 0
 638     var pointerFirstDGBlock = 0
 639     var pointerFileComment = 0
 640     var pointerProgramBlock = 0
 641     var numberDGroups = 0
 642     var date = ""
 643     var time = ""
 644     var author = ""
 645     var organization = ""
 646     var project = ""
 647     var measureObject = ""
 648 
 649     this.makeHDBlock()
 650 
 651     def makeHDBlock(): Unit = {
 652 
 653       var offset = 64
 654       var len = 2
 655       this.blockTypeIdentifier = bytes2str(_bytes, offset, len)
 656       offset += len
 657 
 658       len = 2
 659       this.blockSize = bytes2uint16(_bytes, offset)
 660       offset += len
 661 
 662       len = 4
 663       this.pointerFirstDGBlock = bytes2uint32(_bytes, offset)
 664       offset += len
 665 
 666       len = 4
 667       this.pointerFileComment = bytes2uint32(_bytes, offset)
 668       offset += len
 669 
 670       len = 4
 671       this.pointerProgramBlock = bytes2uint32(_bytes, offset)
 672       offset += len
 673 
 674       len = 2
 675       this.numberDGroups = bytes2uint16(_bytes, offset)
 676       offset += len
 677 
 678       len = 10
 679       this.date = bytes2str(_bytes, offset, len)
 680       offset += len
 681 
 682       len = 8
 683       this.time = bytes2str(_bytes, offset, len)
 684       offset += len
 685 
 686       len = 32
 687       this.author = bytes2str(_bytes, offset, len)
 688       offset += len
 689 
 690       len = 32
 691       this.organization = bytes2str(_bytes, offset, len)
 692       offset += len
 693 
 694       len = 32
 695       this.project = bytes2str(_bytes, offset, len)
 696       offset += len
 697 
 698       len = 32
 699       this.measureObject = bytes2str(_bytes, offset, len)
 700       offset += len
 701 
 702     }
 703   }
 704 
 705   class TXBlock(var _bytes: Array[Byte], var _offset: Int) {
 706     var blockTypeIdentifier = ""
 707     var blockSize = 0
 708     var Text = ""
 709 
 710     this.makeTXBlock()
 711 
 712     def makeTXBlock(): Unit = {
 713       var offset = _offset
 714 
 715       var len = 2
 716 
 717       this.blockTypeIdentifier = bytes2str(_bytes, offset, len)
 718       offset += len
 719 
 720       len = 2
 721 
 722       this.blockSize = bytes2uint16(_bytes, offset)
 723       offset += len
 724 
 725       len = this.blockSize - 4
 726       this.Text = bytes2str(_bytes, offset, len)
 727       offset += len
 728     }
 729   }
 730     
 731     class CEBlock(var _bytes: Array[Byte], var _offset: Int) {
 732         var blockTypeIdentifier = ""
 733         var blockSize = 0
 734         var extensionType = 0
 735         var moduleNumber = 0
 736         var address = 0
 737         var description = ""
 738         var ECUIdentification = ""
 739         var CANMessage = 0
 740         var CANChannelIndex = 0
 741         var messageName = ""
 742         var senderName = ""
 743         
 744         this.makeCEBlock()
 745         
 746         def makeCEBlock(): Unit = {
 747             var offset = _offset
 748             
 749             var len = 2
 750             this.blockTypeIdentifier = bytes2str(_bytes, offset, len)
 751             offset += len
 752             
 753             len = 2
 754             this.blockSize = bytes2uint16(_bytes, offset)
 755             offset += len
 756     
 757             len = 2
 758             this.extensionType = bytes2uint16(_bytes, offset)
 759             offset += len
 760             
 761             if(this.extensionType == 2){
 762                 len = 2
 763                 this.moduleNumber = bytes2uint16(_bytes, offset)
 764                 offset += len
 765     
 766                 len = 4
 767                 this.address = bytes2uint32(_bytes, offset)
 768                 offset += len
 769     
 770                 len = 80
 771                 this.description = bytes2str(_bytes, offset, len)
 772                 offset += len
 773     
 774                 len = 32
 775                 this.ECUIdentification = bytes2str(_bytes, offset, len)
 776                 offset += len
 777             
 778             }
 779             else if(this.extensionType == 19){
 780                 len = 4
 781                 this.moduleNumber = bytes2uint32(_bytes, offset)
 782                 offset += len
 783     
 784                 len = 4
 785                 this.address = bytes2uint32(_bytes, offset)
 786                 offset += len
 787     
 788                 len = 36
 789                 this.description = bytes2str(_bytes, offset, len)
 790                 offset += len
 791     
 792                 len = 36
 793                 this.ECUIdentification = bytes2str(_bytes, offset, len)
 794                 offset += len
 795             }
 796         }
 797     }
 798 
 799   class DGBlock(var _bytes: Array[Byte], var _offset: Int) {
 800     var blockTypeIdentifier = ""
 801     var blockSize = 0
 802     var pointerNextDGBlock = 0
 803     var pointerFirstCGBlock = 0
 804     var pointerTriggerBlock = 0
 805     var pointerDataBlock = 0
 806     var numberCGs = 0
 807     var numberRecordIDs = 0
 808 
 809     var cgBlocks: List[CGBlock] = List()
 810 
 811     this.makeDGBlock()
 812 
 813     def makeDGBlock(): Unit = {
 814 
 815       var offset = _offset
 816       var len = 2
 817       this.blockTypeIdentifier = bytes2str(_bytes, offset, len)
 818       offset += len
 819 
 820       len = 2
 821       this.blockSize = bytes2uint16(_bytes, offset)
 822       offset += len
 823 
 824       len = 4
 825       this.pointerNextDGBlock = bytes2uint32(_bytes, offset)
 826       offset += len
 827 
 828       len = 4
 829       this.pointerFirstCGBlock = bytes2uint32(_bytes, offset)
 830       offset += len
 831 
 832       len = 4
 833       this.pointerTriggerBlock = bytes2uint32(_bytes, offset)
 834       offset += len
 835 
 836       len = 4
 837       this.pointerDataBlock = bytes2uint32(_bytes, offset)
 838       offset += len
 839 
 840       len = 2
 841       this.numberCGs = bytes2uint16(_bytes, offset)
 842       offset += len
 843 
 844       len = 10
 845       this.numberRecordIDs = bytes2uint16(_bytes, offset)
 846       offset += len
 847 
 848       var cg = new CGBlock(_bytes, this.pointerFirstCGBlock)
 849       cgBlocks = cgBlocks :+ cg
 850 
 851       while (cg.pointerNextCGBlock != 0) {
 852         cg = new CGBlock(_bytes, cg.pointerNextCGBlock)
 853         cgBlocks = cgBlocks :+ cg
 854       }
 855 
 856     }
 857   }
 858 
 859   class CGBlock(var _bytes: Array[Byte], var _offset: Int) {
 860     var blockTypeIdentifier = ""
 861     var blockSize = 0
 862     var pointerNextCGBlock = 0
 863     var pointerFirstCNBlock = 0
 864     var pointerComment = 0
 865     var recordID = 0
 866     var numberChannels = 0
 867     var sizeDataRecord = 0
 868     var numberRecords = 0
 869 
 870     var cnBlocks: List[CNBlock] = List()
 871 
 872     this.makeCGBlock()
 873 
 874     def makeCGBlock(): Unit = {
 875 
 876       var offset = _offset
 877       var len = 2
 878       this.blockTypeIdentifier = bytes2str(_bytes, offset, len)
 879       offset += len
 880 
 881       len = 2
 882       this.blockSize = bytes2uint16(_bytes, offset)
 883       offset += len
 884 
 885       len = 4
 886       this.pointerNextCGBlock = bytes2uint32(_bytes, offset)
 887       offset += len
 888 
 889       len = 4
 890       this.pointerFirstCNBlock = bytes2uint32(_bytes, offset)
 891       offset += len
 892 
 893       len = 4
 894       this.pointerComment = bytes2uint32(_bytes, offset)
 895       offset += len
 896 
 897       len = 2
 898       this.recordID = bytes2uint16(_bytes, offset)
 899       offset += len
 900 
 901       len = 2
 902       this.numberChannels = bytes2uint16(_bytes, offset)
 903       offset += len
 904 
 905       len = 2
 906       this.sizeDataRecord = bytes2uint16(_bytes, offset)
 907       offset += len
 908 
 909       len = 4
 910       this.numberRecords = bytes2uint32(_bytes, offset)
 911       offset += len
 912 
 913 
 914       var cn = new CNBlock(_bytes, this.pointerFirstCNBlock)
 915       cnBlocks = cnBlocks :+ cn
 916 
 917       while (cn.pointerNextCNBlock != 0) {
 918         cn = new CNBlock(_bytes, cn.pointerNextCNBlock)
 919         cnBlocks = cnBlocks :+ cn
 920       }
 921     }
 922   }
 923 
 924   class CNBlock(var _bytes: Array[Byte], var _offset: Int) {
 925     var blockTypeIdentifier = ""
 926     var blockSize = 0
 927     var pointerNextCNBlock = 0
 928     var pointerCCBlock = 0
 929     var pointerCEBlock = 0
 930     var pointerCDBlock = 0
 931     var pointerComment = 0
 932     var channelType = 0
 933     var shortSignalName = ""
 934     var signalDescription = ""
 935     var startOffsetInBits = 0
 936     var numberOfBits = 0
 937     var signalDataType = 0
 938     var valueRangeValid = false
 939     var minSignalValue = 0.0
 940     var maxSignalValue = 0.0
 941     var sampleRate = 0.0
 942     var pointerLongSignalName = 0
 943     var pointerDisplayName = 0
 944     var additionalByteOffset = 0
 945 
 946     this.makeCNBlock()
 947 
 948     var ccBlock = new CCBlock(_bytes, this.pointerCCBlock)
 949     var ceBlock = new CEBlock(_bytes, this.pointerCEBlock)
 950     //var txBlock = new TXBlock(_bytes, this.pointerComment)
 951 
 952     def makeCNBlock() = {
 953 
 954       var offset = _offset
 955       var len = 2
 956       this.blockTypeIdentifier = bytes2str(_bytes, offset, len)
 957       offset += len
 958 
 959       len = 2
 960       this.blockSize = bytes2uint16(_bytes, offset)
 961       offset += len
 962 
 963       len = 4
 964       this.pointerNextCNBlock = bytes2uint32(_bytes, offset)
 965       offset += len
 966 
 967       len = 4
 968       this.pointerCCBlock = bytes2uint32(_bytes, offset)
 969       offset += len
 970 
 971       len = 4
 972       this.pointerCEBlock = bytes2uint32(_bytes, offset)
 973       offset += len
 974 
 975       len = 4
 976       this.pointerCDBlock = bytes2uint32(_bytes, offset)
 977       offset += len
 978 
 979       len = 4
 980       this.pointerComment = bytes2uint32(_bytes, offset)
 981       offset += len
 982 
 983       len = 2
 984       this.channelType = bytes2uint16(_bytes, offset)
 985       offset += len
 986 
 987       len = 32
 988       this.shortSignalName = bytes2str(_bytes, offset, len)
 989       offset += len
 990 
 991       len = 128
 992       this.signalDescription = bytes2str(_bytes, offset, len)
 993       offset += len
 994 
 995       len = 2
 996       this.startOffsetInBits = bytes2uint16(_bytes, offset)
 997       offset += len
 998 
 999       len = 2
1000       this.numberOfBits = bytes2uint16(_bytes, offset)
1001       offset += len
1002 
1003       len = 2
1004       this.signalDataType = bytes2uint16(_bytes, offset)
1005       offset += len
1006 
1007       len = 2
1008       this.valueRangeValid = bytes2bool(_bytes, offset)
1009       offset += len
1010 
1011       len = 64
1012       this.minSignalValue = bytes2real(_bytes, offset)
1013       offset += len
1014 
1015       len = 64
1016       this.maxSignalValue = bytes2real(_bytes, offset)
1017       offset += len
1018 
1019       len = 64
1020       this.sampleRate = bytes2real(_bytes, offset)
1021       offset += len
1022 
1023       len = 4
1024       this.pointerLongSignalName = bytes2uint32(_bytes, offset)
1025       offset += len
1026 
1027       len = 4
1028       this.pointerDisplayName = bytes2uint32(_bytes, offset)
1029       offset += len
1030 
1031       len = 2
1032       this.additionalByteOffset = bytes2uint16(_bytes, offset)
1033       offset += len
1034     }
1035   }
1036 
1037   class CCBlock(var _bytes: Array[Byte], var _offset: Int) {
1038     var arrayBuffer: Array[Byte] = _
1039     var blockTypeIdentifier = ""
1040     var blockSize = 0
1041     var physicalValueRangeValid = false
1042     var minPhysicalSignalValue = 0.0
1043     var maxPhysicalSignalValue = 0.0
1044     var physicalUnit = ""
1045     var conversionType = 0
1046     var sizeInformation = 0
1047     var p1 = 0.0
1048     var p2 = 0.0
1049 
1050     //    var additionalConversionData
1051 
1052     this.makeCCBlock()
1053 
1054     def makeCCBlock() = {
1055 
1056       arrayBuffer = _bytes
1057       var offset = _offset
1058       var len = 2
1059       this.blockTypeIdentifier = bytes2str(_bytes, offset, len)
1060       //      println("this.blockTypeIdentifier",this.blockTypeIdentifier)
1061       offset += len
1062 
1063       len = 2
1064       this.blockSize = bytes2uint16(_bytes, offset)
1065       //      println("this.blockSize",this.blockSize)
1066       offset += len
1067 
1068       len = 2
1069       this.physicalValueRangeValid = bytes2bool(_bytes, offset)
1070       //      println("this.physicalValueRangeValid",this.physicalValueRangeValid)
1071       offset += len
1072 
1073       len = 8
1074       this.minPhysicalSignalValue = bytes2real(_bytes, offset)
1075       //      println("this.minPhysicalSignalValue",this.minPhysicalSignalValue)
1076       offset += len
1077 
1078       len = 8
1079       this.maxPhysicalSignalValue = bytes2real(_bytes, offset)
1080       //      println("this.maxPhysicalSignalValue",this.maxPhysicalSignalValue)
1081       offset += len
1082 
1083       len = 20
1084       this.physicalUnit = bytes2str(_bytes, offset, len)
1085       //      println("this.physicalUnit",this.physicalUnit)
1086       offset += len
1087 
1088       len = 2
1089       this.conversionType = bytes2uint16(_bytes, offset)
1090       //      println("this.conversionType",this.conversionType)
1091       offset += len
1092 
1093       len = 2
1094       this.sizeInformation = bytes2uint16(_bytes, offset)
1095       //      println("this.sizeInformation",this.sizeInformation)
1096       offset += len
1097 
1098       len = 8
1099       this.p1 = bytes2real(_bytes, offset)
1100       //      println("this.p1",this.p1)
1101       offset += len
1102 
1103       len = 8
1104       this.p2 = bytes2real(_bytes, offset)
1105       //      println("this.p2",this.p2)
1106       offset += len
1107 
1108     }
1109   }
1110 
1111 
1112   def bytes2str(_bytes: Array[Byte], _offset: Int, _len: Int): String = {
1113     var temp_bytes = new Array[Byte](_len)
1114     for (i <- 0 to _len - 1) {
1115       temp_bytes(i) = _bytes(i + _offset)
1116     }
1117 
1118     return new String(temp_bytes).trim()
1119   }
1120 
1121   def bytes2uint8(_bytes: Array[Byte], _offset: Int): Int = {
1122     var b0 = _bytes(_offset) & 0xff
1123 
1124     return b0
1125   }
1126 
1127   def bytes2uint16(_bytes: Array[Byte], _offset: Int): Int = {
1128     var b0 = _bytes(_offset) & 0xff
1129     var b1 = _bytes(_offset + 1) & 0xff
1130 
1131     return (b1 << 8) | b0
1132   }
1133 
1134   def bytes2uint32(_bytes: Array[Byte], _offset: Int): Int = {
1135 
1136     var b0 = _bytes(_offset) & 0xff
1137     var b1 = _bytes(_offset + 1) & 0xff
1138     var b2 = _bytes(_offset + 2) & 0xff
1139     var b3 = _bytes(_offset + 3) & 0xff
1140 
1141     return (b3 << 24) | (b2 << 16) | (b1 << 8) | b0
1142   }
1143 
1144   def bytes2bool(_bytes: Array[Byte], _offset: Int): Boolean = {
1145     var b0 = _bytes(_offset) & 0xff
1146     var b1 = _bytes(_offset + 1) & 0xff
1147 
1148     return if (((b1 << 8) | b0) != 0) true else false
1149   }
1150 
1151   def bytes2float(_bytes: Array[Byte], _offset: Int): Double = {
1152 
1153     var _array: Array[Byte] = new Array[Byte](4)
1154 
1155     for (i <- 0 until 4) {
1156       _array(i) = _bytes(-i + _offset + 4)
1157     }
1158 
1159     return ByteBuffer.wrap(_array).getFloat()
1160 
1161     //    var b0 = _bytes(_offset) & 0xff
1162     //    var b1 = _bytes(_offset + 1) & 0xff
1163     //    var b2 = _bytes(_offset + 2) & 0xff
1164     //    var b3 = _bytes(_offset + 3) & 0xff
1165 
1166     //    return ((b3 << 24) | (b2 << 16) | (b1 << 8) | b0).toDouble
1167   }
1168 
1169   def bytes2real(_bytes: Array[Byte], _offset: Int): Double = {
1170 
1171     var _array: Array[Byte] = new Array[Byte](8)
1172 
1173     for (i <- 0 until 8) {
1174       _array(i) = _bytes(-i + _offset + 7)
1175     }
1176 
1177     //    var b0 = _bytes(_offset) & 0xff
1178     //    var b1 = _bytes(_offset + 1) & 0xff
1179     //    var b2 = _bytes(_offset + 2) & 0xff
1180     //    var b3 = _bytes(_offset + 3) & 0xff
1181     //    var b4 = _bytes(_offset + 4) & 0xff
1182     //    var b5 = _bytes(_offset + 5) & 0xff
1183     //    var b6 = _bytes(_offset + 6) & 0xff
1184     //    var b7 = _bytes(_offset + 7) & 0xff
1185 
1186     return ByteBuffer.wrap(_array).getDouble
1187 
1188     //    return ((b7 << 56) |(b6 << 48)|(b5 << 40)|(b4 << 32)|(b3 << 24)|(b2 << 16)|(b1 << 8)| b0).toDouble
1189   }
1190   
1191   def bytes2long(_bytes: Array[Byte], _offset: Int): Double = {
1192     
1193     var _array: Array[Byte] = new Array[Byte](8)
1194     
1195     for (i <- 0 until 8) {
1196       _array(i) = _bytes(-i + _offset + 7)
1197     }
1198     return ByteBuffer.wrap(_array).getLong
1199     
1200     //    return ((b7 << 56) |(b6 << 48)|(b5 << 40)|(b4 << 32)|(b3 << 24)|(b2 << 16)|(b1 << 8)| b0).toDouble
1201   }
1202 
1203   def DataReaderBit(_byte: Array[Byte], _startOffsetInBits: Int, _numberOfRecord: Int, _recordSizeInByte: Int): Array[Double] = {
1204     var startposition = _startOffsetInBits / 8
1205     var curPos = startposition
1206 
1207     var result: Array[Double] = new Array[Double](_numberOfRecord)
1208     for (i <- 0 until _numberOfRecord - 1) {
1209       result(i) = bytes2uint8(_byte, curPos)
1210       curPos += _recordSizeInByte
1211     }
1212     return result
1213   }
1214 
1215   def DataReaderUInt(_byte: Array[Byte], _startOffsetInBits: Int, _numberOfRecord: Int, _recordSizeInByte: Int): Array[Double] = {
1216     var startposition = _startOffsetInBits / 8
1217     var curPos = startposition
1218 
1219     var result: Array[Double] = new Array[Double](_numberOfRecord)
1220     for (i <- 0 until _numberOfRecord - 1) {
1221       result(i) = bytes2uint8(_byte, curPos)
1222       curPos += _recordSizeInByte
1223     }
1224 
1225     return result
1226   }
1227 
1228   def DataReaderUInt16(_byte: Array[Byte], _startOffsetInBits: Int, _numberOfRecord: Int, _recordSizeInByte: Int): Array[Double] = {
1229     var startposition = _startOffsetInBits / 8
1230     var curPos = startposition
1231 
1232     var result: Array[Double] = new Array[Double](_numberOfRecord)
1233 
1234     for (i <- 0 until _numberOfRecord - 1) {
1235       result(i) = bytes2uint16(_byte, curPos)
1236       curPos += _recordSizeInByte
1237     }
1238     return result
1239   }
1240   
1241   def DataReaderUInt32(_byte: Array[Byte], _startOffsetInBits: Int, _numberOfRecord: Int, _recordSizeInByte: Int): Array[Double] = {
1242     var startposition = _startOffsetInBits / 8
1243     var curPos = startposition
1244 
1245     var result: Array[Double] = new Array[Double](_numberOfRecord)
1246 
1247     for (i <- 0 until _numberOfRecord - 1) {
1248       result(i) = bytes2uint32(_byte, curPos)
1249       curPos += _recordSizeInByte
1250     }
1251     return result
1252   }
1253 
1254   def DataReaderUInt64(_byte: Array[Byte], _startOffsetInBits: Int, _numberOfRecord: Int, _recordSizeInByte: Int): Array[Double] = {
1255     var startposition = _startOffsetInBits / 8
1256     var curPos = startposition
1257 
1258     var result: Array[Double] = new Array[Double](_numberOfRecord)
1259 
1260     for (i <- 0 until _numberOfRecord - 1) {
1261       result(i) = bytes2long(_byte, curPos)
1262       curPos += _recordSizeInByte
1263     }
1264     return result
1265   }
1266 
1267   def DataReaderFloat(_byte: Array[Byte], _startOffsetInBits: Int, _numberOfRecord: Int, _recordSizeInByte: Int): Array[Double] = {
1268     var startposition = _startOffsetInBits / 8
1269     var curPos = startposition
1270     var result: Array[Double] = new Array[Double](_numberOfRecord)
1271 
1272     for (i <- 0 until _numberOfRecord - 1) {
1273       result(i) = bytes2float(_byte, curPos)
1274       curPos += _recordSizeInByte
1275     }
1276     return result
1277   }
1278 
1279   def DataReaderDouble(_byte: Array[Byte], _startOffsetInBits: Int, _numberOfRecord: Int, _recordSizeInByte: Int): Array[Double] = {
1280     var startposition = _startOffsetInBits / 8
1281     var curPos = startposition
1282 
1283     var result: Array[Double] = new Array[Double](_numberOfRecord)
1284 
1285     for (i <- 0 until _numberOfRecord - 1) {
1286       result(i) = bytes2real(_byte, curPos)
1287       curPos += _recordSizeInByte
1288     }
1289     return result
1290   }
1291 
1292 }