src/owDevice.cpp

   1 // Copyright (c) 2019, Tobias Mueller tm(at)tm3d.de\r
   2 // All rights reserved.\r
   3 //\r
   4 // Redistribution and use in source and binary forms, with or without\r
   5 // modification, are permitted provided that the following conditions are\r
   6 // met:\r
   7 //\r
   8 //  * Redistributions of source code must retain the above copyright\r
   9 //    notice, this list of conditions and the following disclaimer.\r
  10 //  * Redistributions in binary form must reproduce the above copyright\r
  11 //    notice, this list of conditions and the following disclaimer in the\r
  12 //    documentation and/or other materials provided with the\r
  13 //    distribution.\r
  14 //  * All advertising materials mentioning features or use of this\r
  15 //    software must display the following acknowledgement: This product\r
  16 //    includes software developed by tm3d.de and its contributors.\r
  17 //  * Neither the name of tm3d.de nor the names of its contributors may\r
  18 //    be used to endorse or promote products derived from this software\r
  19 //    without specific prior written permission.\r
  20 //\r
  21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
  22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
  23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
  24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
  25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
  26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
  27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
  28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
  29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
  30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  32 \r
  33 \r
  34 #include "owInterface.h"\r
  35 #ifdef LINUX\r
  36 #include <unistd.h>\r
  37 #endif\r
  38 #ifdef WIN\r
  39 void usleep(int waitTime) {\r
  40         __int64 time1 = 0, time2 = 0, freq = 0;\r
  41 \r
  42         QueryPerformanceCounter((LARGE_INTEGER *)&time1);\r
  43         QueryPerformanceFrequency((LARGE_INTEGER *)&freq);\r
  44 \r
  45         do {\r
  46                 QueryPerformanceCounter((LARGE_INTEGER *)&time2);\r
  47         } while ((time2 - time1) < waitTime);\r
  48 }\r
  49 #endif\r
  50 owDevice::owDevice(owInterface *owi_,snum_t num) {\r
  51                 snum=num;\r
  52                 owi=owi_;\r
  53                 config=new owDeviceConfig;\r
  54                 configstate=OWDCS_NONE;\r
  55                 raw.insert(raw.begin(),4,0);\r
  56                 values.insert(values.begin(),4,0);\r
  57                 lastfound=0;\r
  58         }\r
  59         \r
  60 void owDevice::setDefaultConfig() {\r
  61                 config->setInvalid();\r
  62         }\r
  63         \r
  64 std::vector<std::string> owDevice::getFamilyInfo() {\r
  65                 return owDeviceConfig::getFamilyInfo(snum.byte[0]);\r
  66         }\r
  67 int owDevice::readConfig() {\r
  68         std::vector<uint8_t> cl;\r
  69         int r=owi->maxrepeat+1;\r
  70         setDefaultConfig();\r
  71         int conf16=0;\r
  72         do {\r
  73                 owi->log->clear();\r
  74                 cl.clear();\r
  75                 cl.push_back(0x85);\r
  76                 Communicate(&cl, 1, 26);\r
  77                 //for (uint8_t v:cl) printf("%02X ",v); \r
  78                 if ((cl[1]==0xFF)||(cl[2]==0xFF)) {\r
  79                         owi->log->set(OWLOG_INFO,"Get Config not work, maybe not a emulation from www.tm3d.de");\r
  80                         return 0;\r
  81                 }\r
  82                 int oldInfo=1;\r
  83                 //all Code pos +1 \r
  84                 for(int i=19;i<27;i++) if (cl[i]!=0xFF) {oldInfo=0;break;} \r
  85                 if (oldInfo) {\r
  86                         owi->log->set(OWLOG_INFO,"Old 16 Byte Config");\r
  87                         if (cl[18]==0xFF) { \r
  88                                 if (!owi->calcCRC8(std::vector<uint8_t>(cl.begin()+1,cl.begin()+17))) {\r
  89                                         owi->log->set(OWLOG_WARNING,"CRC8 ERROR Reading Config");\r
  90                                 }\r
  91                         } else {\r
  92                                 if (!owi->testCRC16(cl)) {\r
  93                                         owi->log->set(OWLOG_WARNING,"CRC16 ERROR Reading Config ");\r
  94                                 }\r
  95                         }\r
  96                         if (owi->log->last()<OWLOG_WARNING) {\r
  97                                 cl[9]=2; //Attiny84A\r
  98                                 for(int i=0;i<7;i++) {cl[18+i]=cl[10+i];cl[10+i]=0;} //Move OWID2 Set Sensor to 0\r
  99                                 conf16=1;\r
 100 \r
 101                         }\r
 102                 } else { //New CRC\r
 103                         if (cl[26]==0xFF) { \r
 104                                 if (!owi->calcCRC8(std::vector<uint8_t>(cl.begin()+1,cl.begin()+25))) {\r
 105                                         owi->log->set(OWLOG_WARNING,"CRC8 ERROR Reading Config");\r
 106                                 }\r
 107                         } else {\r
 108                                 if (!owi->testCRC16(cl)) {\r
 109                                         owi->log->set(OWLOG_WARNING,"CRC16 ERROR Reading Config ");\r
 110                                 }\r
 111                         }\r
 112                 }               \r
 113                 r--;\r
 114         }\r
 115         while ((owi->log->last()>=OWLOG_WARNING)&&(r>0));\r
 116         if (r==0) {\r
 117                 owi->log->set(OWLOG_ERROR,"To much Errors while read config");\r
 118                 return -1;\r
 119         }\r
 120         config->setConfig(std::vector<uint8_t>(cl.begin()+1,cl.begin()+25));\r
 121         if (config->valid) {\r
 122                 if (conf16) configstate=OWDCS_16; else configstate=OWDCS_24;\r
 123         } else configstate=OWDCS_NONE;\r
 124         return 1;\r
 125 }\r
 126 \r
 127 \r
 128 int owDevice::Communicate(std::vector<uint8_t> *data, int scount, int rcount) {\r
 129         owi->Wait_Free();\r
 130         owi->MatchRom(snum);\r
 131         if (owi->log->last()==OWLOG_ERROR) {owi->Free();return 0;}\r
 132         owi->Communicate(data, scount, rcount);  \r
 133         if (owi->log->last()==OWLOG_ERROR) {owi->Free();return 0;}\r
 134         owi->Free();\r
 135         return 1;\r
 136 }\r
 137 \r
 138 int owDevice::CommunicateShort(std::vector<uint8_t> *data, int scount, int rcount) {\r
 139         owi->Wait_Free();\r
 140         owi->Reset();\r
 141         if (owi->log->last()==OWLOG_ERROR) {owi->Free();return 0;}\r
 142         owi->Communicate(data, scount, rcount);\r
 143         if (owi->log->last()==OWLOG_ERROR) {owi->Free();return 0;}\r
 144         owi->Free();\r
 145         return 1;\r
 146 }\r
 147 \r
 148 \r
 149 void owDevice::changeID(snum_t nid) {\r
 150         int i;\r
 151         if (nid.byte[0] != snum.byte[0]) {\r
 152                 owi->log->set(OWLOG_WARNING,"Family ID should not be changed, no correct ID");\r
 153                 //return;\r
 154         }\r
 155         std::vector<uint8_t> id;\r
 156         for(i=0;i<7;i++) id.push_back(nid.byte[i]);\r
 157         id.push_back(owi->calcCRC8(id));\r
 158         std::vector<uint8_t> cl;\r
 159         int r=owi->maxrepeat+1;\r
 160         do {\r
 161                 owi->log->clear();\r
 162                 cl.clear();\r
 163                 cl.push_back(0x75);\r
 164                 cl.insert(cl.begin()+1,id.begin(),id.end());\r
 165                 Communicate(&cl, 9,0);\r
 166                 if (owi->log->last()==OWLOG_ERROR) {r--;continue;}\r
 167                 cl.clear();\r
 168                 cl.push_back(0xA7);\r
 169                 Communicate(&cl, 1, 8);\r
 170                 if (owi->log->last()==OWLOG_ERROR) {r--;continue;}\r
 171                 for (i = 0; i < 8; i++) {\r
 172                         if (cl[i + 1] != id[i]) {\r
 173                                 owi->log->set(OWLOG_WARNING,"changeID Comunication ERROR");\r
 174                                 break;\r
 175                         }\r
 176                 }\r
 177                 r--;\r
 178         }\r
 179         while ((owi->log->last()>=OWLOG_WARNING)&&(r>0));\r
 180         if (r==0) {\r
 181                 owi->log->set(OWLOG_ERROR,"Can not change ID");\r
 182                 return;\r
 183         }       \r
 184         cl.clear();\r
 185         cl.push_back(0x79);\r
 186         cl.push_back(snum.byte[1]);\r
 187         cl.push_back(snum.byte[5]);\r
 188         cl.push_back(snum.byte[6]);\r
 189         Communicate(&cl, 4, 0);\r
 190         usleep(50000);  \r
 191 }\r
 192 \r
 193 void owDevice::runFlasher() {\r
 194         std::vector<uint8_t> cl;\r
 195         cl.push_back(0x88);\r
 196         this->Communicate(&cl, 1, 0);\r
 197         this->Communicate(&cl, 1, 0);\r
 198         this->Communicate(&cl, 1, 0);\r
 199 }\r
 200 \r
 201 \r
 202 \r
 203 \r
 204 \r
 205 \r
 206 \r
 207 \r
 208 \r
 209 void owDeviceDS18B20::setDefaultConfig() {\r
 210         config->setConfig({1,1, 0,0, 0,0, 0,0, 0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0});\r
 211         configstate=OWDCS_DEFAULT;\r
 212 };\r
 213 \r
 214 int owDeviceDS18B20::readScratchpad(std::vector<uint8_t> *sp) {\r
 215         std::vector<uint8_t> cl;\r
 216         int r=owi->maxrepeat+1;\r
 217         do {\r
 218                 cl.clear();\r
 219                 cl.push_back(0xBE);\r
 220                 Communicate(&cl, 1, 9);\r
 221                 if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 222                 sp->clear();\r
 223                 sp->insert(sp->begin(),cl.begin()+1,cl.end());\r
 224                 if (owi->calcCRC8(*sp)==0) return 1;\r
 225                 owi->log->set(OWLOG_WARNING,"CRC ERROR reading DS18B20 Scrachpad");\r
 226                 r--;\r
 227         } while ((owi->log->last()>=OWLOG_WARNING)&&(r>0));\r
 228                         \r
 229         return 0;\r
 230 }\r
 231 \r
 232 int owDeviceDS18B20::convertAll() {\r
 233         std::vector<uint8_t> sp;\r
 234         if (owCC_44_Temp==0) {\r
 235                 sp.push_back(0x44);\r
 236                 Communicate(&sp, 1, 0); ///########################################################\r
 237                 usleep(750000);\r
 238         }\r
 239         if (readScratchpad(&sp)) {\r
 240                 int16_t tsht;\r
 241                 tsht = sp[0] | ((int)sp[1] << 8);\r
 242                 if (sp[1] & 0x080)\r
 243                         tsht |= 0xFFFFF0000;\r
 244                 raw[0]=tsht;\r
 245                 values[0]=config->calculateValue(0, raw);\r
 246                 return 1;\r
 247         }               \r
 248         return 0;\r
 249 }\r
 250 \r
 251 \r
 252 void owDeviceDS2438::setDefaultConfig() {\r
 253         config->setConfig({1,6, 6,8, 4,7, 6,17, 0,2,3,12,4,0,0,0,0,0,0,0,0,0,0,0});\r
 254         configstate=OWDCS_DEFAULT;\r
 255 }\r
 256 \r
 257 \r
 258 int owDeviceDS2438::readScratchpad(std::vector<uint8_t> *sp, uint8_t page, int recall) {\r
 259         std::vector<uint8_t> cl;\r
 260         int r=owi->maxrepeat+1;\r
 261         do {\r
 262                 if (recall) {\r
 263                         cl.clear();\r
 264                         cl.push_back(0xB8); //recall\r
 265                         cl.push_back(page);\r
 266                         Communicate(&cl, 2, 0);\r
 267                         if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 268                 }\r
 269                 cl.clear();\r
 270                 cl.push_back(0xBE);\r
 271                 cl.push_back(page);\r
 272                 Communicate(&cl, 2, 9);\r
 273                 if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 274                 sp->clear();\r
 275                 sp->insert(sp->begin(),cl.begin()+2,cl.end());\r
 276                 if (owi->calcCRC8(*sp)==0) return 1;\r
 277                 owi->log->set(OWLOG_WARNING,"CRC ERROR reading DS2438 Scrachpad");\r
 278                 r--;\r
 279         } while ((owi->log->last()>=OWLOG_WARNING)&&(r>0));\r
 280                         \r
 281         return 0;\r
 282 }\r
 283 \r
 284 int owDeviceDS2438::readMemory(int page,int start, int count,std::vector<uint8_t> *data) {\r
 285         if ((page>7)||(page<0)||(start>7)||(start<0)||(start+count>8)) return 0;\r
 286         std::vector<uint8_t> cl;\r
 287         cl.clear();\r
 288         cl.push_back(0xB8); //recall\r
 289         cl.push_back(page);\r
 290         Communicate(&cl, 2, 0);\r
 291         if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 292         cl.clear();\r
 293         cl.push_back(0xBE);\r
 294         cl.push_back(page);\r
 295         Communicate(&cl, 2, 9);\r
 296         if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 297         cl.erase(cl.begin());\r
 298         cl.erase(cl.begin());\r
 299         if (owi->calcCRC8(cl)!=0) {\r
 300                 owi->log->set(OWLOG_WARNING,"CRC ERROR reading DS2438 Scrachpad");\r
 301         }\r
 302         data->clear();\r
 303         data->insert(data->begin(),cl.begin()+start,cl.begin()+start+count);\r
 304         return count;\r
 305 }\r
 306 int owDeviceDS2438::writeMemory(int page,int start, int count,std::vector<uint8_t> *data) {\r
 307         if ((page>7)||(page<0)||(start>7)||(start<0)||(start+count>8)) return 0;\r
 308         std::vector<uint8_t> sp;\r
 309         if ((start>0)||(count<8)) {\r
 310                 readMemory(page,0,8,&sp);\r
 311         }\r
 312         std::vector<uint8_t> cl;\r
 313         cl.push_back(0x4E); \r
 314         cl.push_back(page);\r
 315         int j=0;\r
 316         for(int i=0;i<8;i++) {\r
 317                 if ((i<start)||(i>=start+count)) cl.push_back(sp[i]); else {cl.push_back((*data)[j]);j++;}\r
 318         }\r
 319         Communicate(&cl, 10,0);\r
 320         if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 321         std::vector<uint8_t> cl1;\r
 322         cl1.push_back(0xBE);\r
 323         cl1.push_back(page);\r
 324         Communicate(&cl1, 2, 9);\r
 325         if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 326         cl1.erase(cl1.begin());\r
 327         cl1.erase(cl1.begin());\r
 328         if (owi->calcCRC8(cl1)!=0) {\r
 329                 owi->log->set(OWLOG_WARNING,"CRC ERROR rereading DS2438 Scrachpad");\r
 330         }\r
 331         for(int i=0;i<8;i++) {\r
 332                 if (cl1[i]!=cl[i+2]) {\r
 333                         owi->log->set(OWLOG_ERROR,"Reread not equal, nothing copied");\r
 334                         return 0; \r
 335                 }\r
 336         }\r
 337         cl.clear();\r
 338         cl.push_back(0x48);\r
 339         cl.push_back(page);\r
 340         Communicate(&cl, 2, 0);\r
 341         if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 342         return 1;\r
 343 }\r
 344 \r
 345 \r
 346 \r
 347 int owDeviceDS2438::setConfigByte(uint8_t cb) {\r
 348         std::vector<uint8_t> sp;\r
 349         int k;\r
 350         for(k=0;k<owi->maxrepeat;k++) {\r
 351                 owi->log->clear();\r
 352                 sp.clear();\r
 353                 sp.push_back(0x4E);\r
 354                 sp.push_back(0x00);\r
 355                 sp.push_back(cb);\r
 356                 Communicate(&sp,3,0);\r
 357                 if (owi->log->last()>=OWLOG_ERROR) return -1;\r
 358                 sp.clear();\r
 359                 readScratchpad(&sp,0,0);\r
 360                 if (owi->log->last()>=OWLOG_ERROR) return -2;\r
 361                 if (cb==sp[0]) return 1;\r
 362                 owi->log->set(OWLOG_WARNING,"ERROR set config byte of DS2438");\r
 363         }\r
 364         owi->log->set(OWLOG_WARNING,"Config of DS2438 byte not set");\r
 365         return 0;\r
 366 }\r
 367 \r
 368 inline int16_t ow_fconvert(uint8_t b1, uint16_t b2) {\r
 369   int tsht;\r
 370   tsht=b1  |((int)b2<<8);\r
 371   if (b2 & 0x080)\r
 372         tsht |= 0xFFFFF0000;\r
 373   return tsht;\r
 374 }\r
 375 \r
 376 int owDeviceDS2438::convertAll() {\r
 377         for(int k=0;k<owi->maxrepeat;k++)  {\r
 378                 std::vector<uint8_t> sp;\r
 379                 if (owCC_44_Temp==0) {\r
 380                         sp.push_back(0x44);\r
 381                         Communicate(&sp, 1, 0);///########################################################\r
 382                         if (owi->log->last()>=OWLOG_ERROR) continue;\r
 383                         usleep(100000);\r
 384                 }\r
 385                 if (setConfigByte(0x08)<=0) continue;\r
 386                 for(int k=0;k<owi->maxrepeat;k++) {\r
 387                         sp.clear();\r
 388                         sp.push_back(0xB4);\r
 389                         Communicate(&sp, 1, 0);\r
 390                 }\r
 391                 if (owi->log->last()>=OWLOG_ERROR) continue;\r
 392                 usleep(100000);\r
 393 \r
 394 \r
 395                 readScratchpad(&sp,0,1);\r
 396                 int temp=ow_fconvert(sp[1],sp[2]);\r
 397                 int VDD=ow_fconvert(sp[3],sp[4]);\r
 398                 if (setConfigByte(0x00)<=0) continue;\r
 399 \r
 400                 for(int k=0;k<owi->maxrepeat;k++) {\r
 401                         sp.clear();\r
 402                         sp.push_back(0xB4);\r
 403                         Communicate(&sp, 1, 0);\r
 404                 }\r
 405                 if (owi->log->last()>=OWLOG_ERROR) continue;\r
 406 \r
 407                 usleep(100000);\r
 408 \r
 409 \r
 410 \r
 411                 readScratchpad(&sp,0,1);\r
 412                 if (owi->log->last()>=OWLOG_ERROR) continue;\r
 413                 int I=ow_fconvert(sp[5],sp[6]);\r
 414                 int VAD=ow_fconvert(sp[3],sp[4]);\r
 415                 raw[0]=temp;\r
 416                 raw[1]=VDD;\r
 417                 raw[2]=VAD;\r
 418                 raw[3]=I;\r
 419                 for(int i=0;i<4;i++) values[i]=config->calculateValue(i, raw);\r
 420                 break;\r
 421         }\r
 422         if (owi->log->last()>=OWLOG_ERROR) return 0;\r
 423         return 1;\r
 424 }\r
 425 \r
 426 \r
 427 void owDeviceDS2450::setDefaultConfig() {\r
 428         config->setConfig({6,9, 6,9, 6,9, 6,9, 0,5,5,5,5,0,0,0,0,0,0,0,0,0,0,0});\r
 429         configstate=OWDCS_DEFAULT;\r
 430 }\r
 431 \r
 432 int owDeviceDS2450::convertAll() {\r
 433         convert(0x0F,0);\r
 434         if (owi->log->last()>=OWLOG_WARNING) {\r
 435                 return 0;\r
 436         }\r
 437         std::vector<uint8_t> sp;\r
 438         readMemory(0,0,8,&sp);\r
 439         if (owi->log->last()>=OWLOG_WARNING) {\r
 440                 return 0;\r
 441         }\r
 442 \r
 443         for(int i=0;i<4;i++) {\r
 444                 raw[i]=(sp[2 * i] | sp[2 * i + 1] << 8);\r
 445         }\r
 446         for(int i=0;i<4;i++) {\r
 447                 values[i]=config->calculateValue(i, raw);\r
 448         }\r
 449         return 1;\r
 450 \r
 451 }\r
 452 \r
 453 int owDeviceDS2450::readMemory(int page,int start, int count,std::vector<uint8_t> *data) {\r
 454         std::vector<uint8_t> cl;\r
 455         cl.push_back(0xAA);\r
 456         cl.push_back(page*8+start);\r
 457         cl.push_back(0x00);\r
 458         Communicate(&cl,3,10-start);\r
 459         if (owi->log->last()>=OWLOG_WARNING) {\r
 460                 return 0;\r
 461         }\r
 462         if (!owi->testCRC16(cl)) {\r
 463                 for (uint8_t v :cl) printf("%02X ",v);\r
 464                 printf("\n");\r
 465                 owi->log->set(OWLOG_ERROR,"CRC ERROR Reading Memory of DS2450");\r
 466                 return 0;\r
 467         }\r
 468         data->clear();\r
 469         data->insert(data->begin(),cl.begin()+3,cl.end()-2);\r
 470         return count;\r
 471 }\r
 472 int owDeviceDS2450::writeMemory(int page,int start, int count,std::vector<uint8_t> *data) {\r
 473         std::vector<uint8_t> cl;\r
 474         cl.push_back(0x55);\r
 475         cl.push_back(page*8+start);\r
 476         cl.push_back(0x00);\r
 477         owi->MatchRom(snum);\r
 478         if (owi->log->last()>=OWLOG_WARNING) {\r
 479                 return 0;\r
 480         }\r
 481         int i=0;\r
 482         for(uint8_t b: (*data)) {\r
 483                 cl.push_back(b);\r
 484                 owi->Communicate(&cl,cl.size(),2);\r
 485                 if (owi->log->last()>=OWLOG_WARNING) {\r
 486                         return 0;\r
 487                 }\r
 488                 if (i>0) {\r
 489                         if (!owi->testCRC16(cl,i+page*8+start)) {\r
 490                                 owi->log->set(OWLOG_ERROR,"CRC ERROR Writing Memory of DS2450");\r
 491                                 return 0;\r
 492                         }\r
 493                 } else {\r
 494                         if (!owi->testCRC16(cl)) {\r
 495                                 owi->log->set(OWLOG_ERROR,"CRC ERROR Writing Memory of DS2450");\r
 496                                 return 0;\r
 497                         }\r
 498                 }\r
 499                 cl.clear();\r
 500                 owi->Communicate(&cl, 0, 1);\r
 501                 if (owi->log->last()>=OWLOG_WARNING) {\r
 502                         return 0;\r
 503                 }\r
 504                 if (cl[0] != b) {\r
 505                         owi->log->set(OWLOG_ERROR,"ERROR Writing Memory of DS2450");\r
 506                         return 0;\r
 507                 }\r
 508                 cl.clear();\r
 509                 i++;\r
 510         }\r
 511         return count;\r
 512 }\r
 513 \r
 514 \r
 515 void owDeviceDS2450::readMemory_int(uint8_t addr,std::vector<uint8_t> *sp) {\r
 516         std::vector<uint8_t> cl;\r
 517         cl.push_back(0xAA);\r
 518         cl.push_back(addr);\r
 519         cl.push_back(0x00);\r
 520         Communicate(&cl,3,10-addr);\r
 521         if (owi->log->last()>=OWLOG_WARNING) {\r
 522                 return;\r
 523         }\r
 524         if (!owi->testCRC16(cl)) {\r
 525                 for (uint8_t v :cl) printf("%02X ",v);\r
 526                 printf("\n");\r
 527                 owi->log->set(OWLOG_ERROR,"CRC ERROR Reading Memory of DS2450");\r
 528                 return;\r
 529         }\r
 530         sp->clear();\r
 531         sp->insert(sp->begin(),cl.begin()+3,cl.end()-2);\r
 532 }\r
 533 \r
 534 void owDeviceDS2450::writeMemory_int(uint8_t addr,std::vector<uint8_t> *sp) {\r
 535         std::vector<uint8_t> cl;\r
 536         cl.push_back(0x55);\r
 537         cl.push_back(addr);\r
 538         cl.push_back(0x00);\r
 539         owi->MatchRom(snum);\r
 540         if (owi->log->last()>=OWLOG_WARNING) {\r
 541                 return;\r
 542         }\r
 543         for(uint8_t b: (*sp)) {\r
 544                 cl.push_back(b);\r
 545                 owi->Communicate(&cl,cl.size(),2);\r
 546                 if (owi->log->last()>=OWLOG_WARNING) {\r
 547                         return;\r
 548                 }\r
 549                 if (!owi->testCRC16(cl)) {\r
 550                         owi->log->set(OWLOG_ERROR,"CRC ERROR Writing Memory of DS2450");\r
 551                         return;\r
 552                 }\r
 553                 cl.clear();\r
 554                 owi->Communicate(&cl, 0, 1);\r
 555                 if (owi->log->last()>=OWLOG_WARNING) {\r
 556                         return;\r
 557                 }\r
 558                 if (cl[0] != b) {\r
 559                         owi->log->set(OWLOG_ERROR,"ERROR Writing Memory of DS2450");\r
 560                         return;\r
 561                 }\r
 562                 cl.clear();\r
 563         }\r
 564 }\r
 565         \r
 566 void owDeviceDS2450::convert(uint8_t mask, uint8_t preset) {\r
 567         std::vector<uint8_t> cl;\r
 568         cl.push_back(0x3C);\r
 569         cl.push_back(mask);\r
 570         cl.push_back(preset);\r
 571         Communicate(&cl, 3, 2);\r
 572         if (!owi->testCRC16(cl)) {\r
 573                 for (uint8_t v :cl) printf("%02X ",v);\r
 574                 printf("\n");\r
 575                 owi->log->set(OWLOG_ERROR,"CRC ERROR Convert Command of DS2450");\r
 576                 return;\r
 577         }\r
 578         usleep(10000);\r
 579 }\r
 580 \r
 581 \r
 582 \r
 583 \r
 584 \r
 585 \r
 586 \r
 587 \r
 588 \r
 589 \r
 590 \r
 591 void owDeviceDS2423::setDefaultConfig() {\r
 592         config->setConfig({9,13, 9,13, 9,13, 9,13, 0,19,19,19,19,0,0,0,0,0,0,0,0,0,0,0});\r
 593         configstate=OWDCS_DEFAULT;\r
 594 }\r
 595 \r
 596 int owDeviceDS2423::convertAll() {\r
 597         for(uint8_t i=12;i<16;i++) {\r
 598                 raw[i-12]=readCounter(i);\r
 599         }\r
 600         for(int i=0;i<4;i++) {\r
 601                 values[i]=config->calculateValue(i, raw);\r
 602         }\r
 603         return 1;\r
 604 }\r
 605 uint32_t owDeviceDS2423::readCounter(uint8_t page) {\r
 606         std::vector<uint8_t> cl;\r
 607         cl.push_back(0xA5);\r
 608         uint16_t addr=(page<<5)+31;\r
 609         cl.push_back(addr&0xFF);\r
 610         cl.push_back(addr>>8);\r
 611         Communicate(&cl,3,11);\r
 612         //for (uint8_t v :cl) printf("%02X ",v);\r
 613         //printf("\n");\r
 614         if (!owi->testCRC16(cl)) {\r
 615                 owi->log->set(OWLOG_ERROR,"CRC ERROR Reading Counter of DS2423");\r
 616                 return 0;\r
 617         }\r
 618         uint32_t ret=0;\r
 619          \r
 620         for(size_t i=cl.size()-7;i>cl.size()-11;i--) {\r
 621                 ret<<=8;\r
 622                 ret|=cl[i];\r
 623                 \r
 624         }\r
 625         return ret;\r
 626 }\r
 627 \r
 628 \r
 629 int owDeviceDS2423::readMemory(int page,int start, int count,std::vector<uint8_t> *data){\r
 630         std::vector<uint8_t> cl;\r
 631         cl.push_back(0xF0);\r
 632         uint16_t adr=page<<5;\r
 633         cl.push_back(adr&0xFF);\r
 634         cl.push_back((adr>>8)&0xFF);\r
 635         Communicate(&cl, 3, 32);\r
 636         //No CRC \r
 637         data->clear();\r
 638         data->insert(data->begin(),cl.begin()+3+start,cl.begin()+start+3+count);\r
 639         return count;   \r
 640 \r
 641 }\r
 642 int owDeviceDS2423::writeMemory(int page,int start, int count,std::vector<uint8_t> *data) {\r
 643         std::vector<uint8_t> cl;\r
 644         cl.push_back(0x0F);\r
 645         uint16_t adr=(page<<5)+start;\r
 646         cl.push_back(adr&0xFF);\r
 647         cl.push_back(adr>>8);\r
 648         if (count > (int)(*data).size()) count = (*data).size();\r
 649         for(int i=0;i<count;i++) {\r
 650                 cl.push_back((*data)[i]);\r
 651         }\r
 652         Communicate(&cl, 3+count, 0);\r
 653         for (uint8_t v :cl) printf("%02X ",v);printf("\n");\r
 654         cl.clear();\r
 655         cl.push_back(0xAA);\r
 656         Communicate(&cl, 1, 36);\r
 657         //for (uint8_t v :cl) printf("%02X ",v);;printf("\n");\r
 658         cl[0]=0x5A;\r
 659         Communicate(&cl, 4, 1);\r
 660         usleep(100000);\r
 661         if (cl[4]!=0xAA) {\r
 662                 for (uint8_t v :cl) printf("%02X ",v);;printf("\n");\r
 663                 owi->log->set(OWLOG_ERROR,"DS2423 Copy from Scratchpad to Memmory Error");\r
 664                 //return 0;\r
 665         }\r
 666         return count;\r
 667 }\r
 668 \r
 669 \r
 670 \r
 671 \r
 672 \r
 673 \r