├── bq2589x.cpp ├── bq2589x.h ├── bq2589x_reg.h ├── examples └── basic │ └── basic.pde ├── keywords.txt └── readme.md /bq2589x.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "bq2589x.h" 3 | 4 | bq2589x::bq2589x(/* args */) 5 | { 6 | } 7 | 8 | bq2589x::~bq2589x() 9 | { 10 | } 11 | 12 | /*! 13 | * @brief Initialise sensor with given parameters / settings 14 | * @param addr the I2C address the device can be found on 15 | * @returns true on success, false otherwise 16 | */ 17 | int bq2589x::begin(uint8_t addr) 18 | { 19 | _i2caddr = addr; 20 | _wire = &Wire; 21 | return reset_chip(); 22 | } 23 | 24 | /*! 25 | * @brief Initialise sensor with given parameters / settings 26 | * @param addr the I2C address the device can be found on 27 | * @param theWire the I2C object to use 28 | * @returns true on success, false otherwise 29 | */ 30 | int bq2589x::begin(uint8_t addr, TwoWire *theWire) 31 | { 32 | _i2caddr = addr; 33 | _wire = theWire; 34 | return reset_chip(); 35 | } 36 | 37 | /*! 38 | * @brief Initialise sensor with given parameters / settings 39 | * @returns true on success, false otherwise 40 | */ 41 | int bq2589x::begin(void) 42 | { 43 | 44 | _i2caddr = BQ25895_ADDR; 45 | _wire = &Wire; 46 | return reset_chip(); 47 | } 48 | 49 | int bq2589x::begin(TwoWire *theWire) 50 | { 51 | _wire = theWire; 52 | _i2caddr = BQ25895_ADDR; 53 | return reset_chip(); 54 | } 55 | 56 | int bq2589x::read_byte(uint8_t *data, uint8_t reg) 57 | { 58 | 59 | int rtn; 60 | _wire->beginTransmission((uint8_t)_i2caddr); 61 | _wire->write(reg); 62 | rtn = _wire->endTransmission(); 63 | 64 | _wire->requestFrom((uint8_t)_i2caddr, (uint8_t)1); 65 | delayMicroseconds(100); 66 | *data = _wire->read(); 67 | 68 | if (rtn == I2C_OK) 69 | { 70 | //Serial.println("BQ25895 Write OK"); 71 | return BQ2589X_OK; //TI lib uses 1 as failed 72 | } 73 | else 74 | { 75 | //Serial.println("BQ25895 Write Err"); 76 | return BQ2589X_ERR; //TI lib uses 1 as failed 77 | } 78 | } 79 | 80 | int bq2589x::write_byte(uint8_t reg, uint8_t data) 81 | { 82 | int rtn; 83 | _wire->beginTransmission((uint8_t)_i2caddr); 84 | _wire->write((uint8_t)reg); 85 | _wire->write((uint8_t)data); 86 | // Serial.printf("Write address 0x%02x , data 0x%02x\r\n", reg, data); 87 | rtn = _wire->endTransmission(); 88 | 89 | if (rtn == I2C_OK) 90 | { 91 | // Serial.println("BQ25895 Write OK"); 92 | return BQ2589X_OK; //TI lib uses 1 as failed 93 | } 94 | else 95 | { 96 | // Serial.println("BQ25895 Write Err"); 97 | return BQ2589X_ERR; //TI lib uses 1 as failed 98 | } 99 | } 100 | 101 | int bq2589x::update_bits(uint8_t reg, uint8_t mask, uint8_t data) 102 | { 103 | int ret; 104 | uint8_t tmp; 105 | 106 | ret = read_byte(&tmp, reg); 107 | 108 | if (ret) 109 | return ret; 110 | 111 | tmp &= ~mask; 112 | tmp |= data & mask; 113 | 114 | return write_byte(reg, tmp); 115 | } 116 | 117 | bq2589x_vbus_type bq2589x::get_vbus_type() 118 | { 119 | uint8_t val = 0; 120 | int ret; 121 | 122 | ret = read_byte(&val, BQ2589X_REG_0B); 123 | if (ret) 124 | return (BQ2589X_VBUS_UNKNOWN); 125 | val &= BQ2589X_VBUS_STAT_MASK; 126 | val >>= BQ2589X_VBUS_STAT_SHIFT; 127 | 128 | return (bq2589x_vbus_type)val; 129 | } 130 | 131 | int bq2589x::enable_otg() 132 | { 133 | uint8_t val = BQ2589X_OTG_ENABLE << BQ2589X_OTG_CONFIG_SHIFT; 134 | 135 | return update_bits(BQ2589X_REG_03, 136 | BQ2589X_OTG_CONFIG_MASK, val); 137 | } 138 | 139 | int bq2589x::disable_otg() 140 | { 141 | uint8_t val = BQ2589X_OTG_DISABLE << BQ2589X_OTG_CONFIG_SHIFT; 142 | 143 | return update_bits(BQ2589X_REG_03, 144 | BQ2589X_OTG_CONFIG_MASK, val); 145 | } 146 | 147 | int bq2589x::set_otg_volt(uint16_t volt) 148 | { 149 | uint8_t val = 0; 150 | 151 | if (volt < BQ2589X_BOOSTV_BASE) 152 | volt = BQ2589X_BOOSTV_BASE; 153 | if (volt > BQ2589X_BOOSTV_BASE + (BQ2589X_BOOSTV_MASK >> BQ2589X_BOOSTV_SHIFT) * BQ2589X_BOOSTV_LSB) 154 | volt = BQ2589X_BOOSTV_BASE + (BQ2589X_BOOSTV_MASK >> BQ2589X_BOOSTV_SHIFT) * BQ2589X_BOOSTV_LSB; 155 | 156 | val = ((volt - BQ2589X_BOOSTV_BASE) / BQ2589X_BOOSTV_LSB) << BQ2589X_BOOSTV_SHIFT; 157 | 158 | return update_bits(BQ2589X_REG_0A, BQ2589X_BOOSTV_MASK, val); 159 | } 160 | 161 | int bq2589x::set_otg_current(int curr) 162 | { 163 | uint8_t temp; 164 | 165 | if (curr == 500) 166 | temp = BQ2589X_BOOST_LIM_500MA; 167 | else if (curr == 700) 168 | temp = BQ2589X_BOOST_LIM_700MA; 169 | else if (curr == 1100) 170 | temp = BQ2589X_BOOST_LIM_1100MA; 171 | else if (curr == 1600) 172 | temp = BQ2589X_BOOST_LIM_1600MA; 173 | else if (curr == 1800) 174 | temp = BQ2589X_BOOST_LIM_1800MA; 175 | else if (curr == 2100) 176 | temp = BQ2589X_BOOST_LIM_2100MA; 177 | else if (curr == 2400) 178 | temp = BQ2589X_BOOST_LIM_2400MA; 179 | else 180 | temp = BQ2589X_BOOST_LIM_1300MA; 181 | 182 | return update_bits(BQ2589X_REG_0A, BQ2589X_BOOST_LIM_MASK, temp << BQ2589X_BOOST_LIM_SHIFT); 183 | } 184 | 185 | int bq2589x::enable_charger() 186 | { 187 | uint8_t val = BQ2589X_CHG_ENABLE << BQ2589X_CHG_CONFIG_SHIFT; 188 | return update_bits(BQ2589X_REG_03, BQ2589X_CHG_CONFIG_MASK, val); 189 | } 190 | 191 | int bq2589x::disable_charger() 192 | { 193 | uint8_t val = BQ2589X_CHG_DISABLE << BQ2589X_CHG_CONFIG_SHIFT; 194 | return update_bits(BQ2589X_REG_03, BQ2589X_CHG_CONFIG_MASK, val); 195 | } 196 | 197 | /* interfaces that can be called by other module */ 198 | int bq2589x::adc_start(bool oneshot) 199 | { 200 | uint8_t val; 201 | int ret; 202 | 203 | ret = read_byte(&val, BQ2589X_REG_02); 204 | if (ret) 205 | { 206 | return ret; 207 | } 208 | 209 | if (((val & BQ2589X_CONV_RATE_MASK) >> BQ2589X_CONV_RATE_SHIFT) == BQ2589X_ADC_CONTINUE_ENABLE) 210 | return BQ2589X_OK; /*is doing continuous scan*/ 211 | if (oneshot) 212 | ret = update_bits(BQ2589X_REG_02, BQ2589X_CONV_START_MASK, BQ2589X_CONV_START << BQ2589X_CONV_START_SHIFT); 213 | else 214 | ret = update_bits(BQ2589X_REG_02, BQ2589X_CONV_RATE_MASK, BQ2589X_ADC_CONTINUE_ENABLE << BQ2589X_CONV_RATE_SHIFT); 215 | return ret; 216 | } 217 | 218 | int bq2589x::adc_stop() 219 | { 220 | return update_bits(BQ2589X_REG_02, BQ2589X_CONV_RATE_MASK, BQ2589X_ADC_CONTINUE_DISABLE << BQ2589X_CONV_RATE_SHIFT); 221 | } 222 | 223 | int bq2589x::adc_read_battery_volt() 224 | { 225 | uint8_t val; 226 | int volt; 227 | int ret; 228 | ret = read_byte(&val, BQ2589X_REG_0E); 229 | if (ret) 230 | { 231 | return ret; 232 | } 233 | else 234 | { 235 | 236 | volt = (BQ2589X_BATV_BASE + ((val & BQ2589X_BATV_MASK) >> BQ2589X_BATV_SHIFT) * BQ2589X_BATV_LSB); 237 | return volt; 238 | } 239 | } 240 | 241 | int bq2589x::adc_read_sys_volt() 242 | { 243 | uint8_t val; 244 | int volt; 245 | int ret; 246 | ret = read_byte(&val, BQ2589X_REG_0F); 247 | if (ret) 248 | { 249 | return ret; 250 | } 251 | else 252 | { 253 | volt = BQ2589X_SYSV_BASE + ((val & BQ2589X_SYSV_MASK) >> BQ2589X_SYSV_SHIFT) * BQ2589X_SYSV_LSB; 254 | return volt; 255 | } 256 | } 257 | 258 | int bq2589x::adc_read_vbus_volt() 259 | { 260 | uint8_t val; 261 | int volt; 262 | int ret; 263 | ret = read_byte(&val, BQ2589X_REG_11); 264 | if (ret) 265 | { 266 | return ret; 267 | } 268 | else 269 | { 270 | volt = BQ2589X_VBUSV_BASE + ((val & BQ2589X_VBUSV_MASK) >> BQ2589X_VBUSV_SHIFT) * BQ2589X_VBUSV_LSB; 271 | 272 | return volt; 273 | } 274 | } 275 | 276 | int bq2589x::adc_read_temperature() 277 | { 278 | uint8_t val; 279 | int temp; 280 | int ret; 281 | ret = read_byte(&val, BQ2589X_REG_10); 282 | if (ret) 283 | { 284 | return ret; 285 | } 286 | else 287 | { 288 | temp = BQ2589X_TSPCT_BASE + ((val & BQ2589X_TSPCT_MASK) >> BQ2589X_TSPCT_SHIFT) * BQ2589X_TSPCT_LSB; 289 | return temp; 290 | } 291 | } 292 | 293 | int bq2589x::adc_read_charge_current() 294 | { 295 | uint8_t val; 296 | int volt; 297 | int ret; 298 | ret = read_byte(&val, BQ2589X_REG_12); 299 | if (ret) 300 | { 301 | return ret; 302 | } 303 | else 304 | { 305 | volt = (int)(BQ2589X_ICHGR_BASE + ((val & BQ2589X_ICHGR_MASK) >> BQ2589X_ICHGR_SHIFT) * BQ2589X_ICHGR_LSB); 306 | return volt; 307 | } 308 | } 309 | 310 | int bq2589x::set_charge_current(int curr) 311 | { 312 | uint8_t ichg; 313 | ichg = (curr - BQ2589X_ICHG_BASE) / BQ2589X_ICHG_LSB; 314 | return update_bits(BQ2589X_REG_04, BQ2589X_ICHG_MASK, ichg << BQ2589X_ICHG_SHIFT); 315 | } 316 | 317 | int bq2589x::set_term_current(int curr) 318 | { 319 | uint8_t iterm; 320 | 321 | iterm = (curr - BQ2589X_ITERM_BASE) / BQ2589X_ITERM_LSB; 322 | 323 | return update_bits(BQ2589X_REG_05, BQ2589X_ITERM_MASK, iterm << BQ2589X_ITERM_SHIFT); 324 | } 325 | 326 | int bq2589x::set_prechg_current(int curr) 327 | { 328 | uint8_t iprechg; 329 | 330 | iprechg = (curr - BQ2589X_IPRECHG_BASE) / BQ2589X_IPRECHG_LSB; 331 | 332 | return update_bits(BQ2589X_REG_05, BQ2589X_IPRECHG_MASK, iprechg << BQ2589X_IPRECHG_SHIFT); 333 | } 334 | 335 | int bq2589x::set_chargevoltage(int volt) 336 | { 337 | uint8_t val; 338 | 339 | val = (volt - BQ2589X_VREG_BASE) / BQ2589X_VREG_LSB; 340 | return update_bits(BQ2589X_REG_06, BQ2589X_VREG_MASK, val << BQ2589X_VREG_SHIFT); 341 | } 342 | 343 | int bq2589x::set_input_volt_limit(int volt) 344 | { 345 | uint8_t val; 346 | val = (volt - BQ2589X_VINDPM_BASE) / BQ2589X_VINDPM_LSB; 347 | return update_bits(BQ2589X_REG_0D, BQ2589X_VINDPM_MASK, val << BQ2589X_VINDPM_SHIFT); 348 | } 349 | 350 | int bq2589x::set_input_current_limit(int curr) 351 | { 352 | uint8_t val; 353 | 354 | val = (curr - BQ2589X_IINLIM_BASE) / BQ2589X_IINLIM_LSB; 355 | return update_bits(BQ2589X_REG_00, BQ2589X_IINLIM_MASK, val << BQ2589X_IINLIM_SHIFT); 356 | } 357 | 358 | int bq2589x::set_vindpm_offset(int offset) 359 | { 360 | uint8_t val; 361 | 362 | val = (offset - BQ2589X_VINDPMOS_BASE) / BQ2589X_VINDPMOS_LSB; 363 | return update_bits(BQ2589X_REG_01, BQ2589X_VINDPMOS_MASK, val << BQ2589X_VINDPMOS_SHIFT); 364 | } 365 | 366 | int bq2589x::get_charging_status() 367 | { 368 | uint8_t val = 0; 369 | int ret; 370 | 371 | ret = read_byte(&val, BQ2589X_REG_0B); 372 | if (ret) 373 | { 374 | return 0x04; //Error 375 | } 376 | val &= BQ2589X_CHRG_STAT_MASK; 377 | val >>= BQ2589X_CHRG_STAT_SHIFT; 378 | return val; 379 | } 380 | 381 | void bq2589x::bq2589x_set_otg(int enable) 382 | { 383 | int ret; 384 | 385 | if (enable) 386 | { 387 | ret = enable_otg(); 388 | if (ret) 389 | { 390 | return; 391 | } 392 | } 393 | else 394 | { 395 | ret = disable_otg(); 396 | } 397 | } 398 | 399 | int bq2589x::set_watchdog_timer(uint8_t timeout) 400 | { 401 | return update_bits(BQ2589X_REG_07, BQ2589X_WDT_MASK, (uint8_t)((timeout - BQ2589X_WDT_BASE) / BQ2589X_WDT_LSB) << BQ2589X_WDT_SHIFT); 402 | } 403 | 404 | int bq2589x::disable_watchdog_timer() 405 | { 406 | uint8_t val = BQ2589X_WDT_DISABLE << BQ2589X_WDT_SHIFT; 407 | 408 | return update_bits(BQ2589X_REG_07, BQ2589X_WDT_MASK, val); 409 | } 410 | 411 | int bq2589x::reset_watchdog_timer() 412 | { 413 | uint8_t val = BQ2589X_WDT_RESET << BQ2589X_WDT_RESET_SHIFT; 414 | 415 | return update_bits(BQ2589X_REG_03, BQ2589X_WDT_RESET_MASK, val); 416 | } 417 | 418 | int bq2589x::force_dpdm() 419 | { 420 | int ret; 421 | uint8_t val = BQ2589X_FORCE_DPDM << BQ2589X_FORCE_DPDM_SHIFT; 422 | 423 | ret = update_bits(BQ2589X_REG_02, BQ2589X_FORCE_DPDM_MASK, val); 424 | if (ret) 425 | return ret; 426 | 427 | //msleep(20);/*TODO: how much time needed to finish dpdm detect?*/ 428 | return BQ2589X_OK; 429 | } 430 | 431 | int bq2589x::reset_chip() 432 | { 433 | int ret; 434 | uint8_t val = BQ2589X_RESET << BQ2589X_RESET_SHIFT; 435 | 436 | ret = update_bits(BQ2589X_REG_14, BQ2589X_RESET_MASK, val); 437 | return ret; 438 | } 439 | 440 | int bq2589x::enter_ship_mode() 441 | { 442 | int ret; 443 | uint8_t val = BQ2589X_BATFET_OFF << BQ2589X_BATFET_DIS_SHIFT; 444 | 445 | ret = update_bits(BQ2589X_REG_09, BQ2589X_BATFET_DIS_MASK, val); 446 | return ret; 447 | } 448 | 449 | int bq2589x::enter_hiz_mode() 450 | { 451 | uint8_t val = BQ2589X_HIZ_ENABLE << BQ2589X_ENHIZ_SHIFT; 452 | 453 | return update_bits(BQ2589X_REG_00, BQ2589X_ENHIZ_MASK, val); 454 | } 455 | 456 | int bq2589x::exit_hiz_mode() 457 | { 458 | 459 | uint8_t val = BQ2589X_HIZ_DISABLE << BQ2589X_ENHIZ_SHIFT; 460 | 461 | return update_bits(BQ2589X_REG_00, BQ2589X_ENHIZ_MASK, val); 462 | } 463 | 464 | int bq2589x::get_hiz_mode(uint8_t *state) 465 | { 466 | uint8_t val; 467 | int ret; 468 | 469 | ret = read_byte(&val, BQ2589X_REG_00); 470 | if (ret) 471 | return ret; 472 | *state = (val & BQ2589X_ENHIZ_MASK) >> BQ2589X_ENHIZ_SHIFT; 473 | 474 | return BQ2589X_OK; 475 | } 476 | 477 | int bq2589x::pumpx_enable(int enable) 478 | { 479 | uint8_t val; 480 | int ret; 481 | 482 | if (enable) 483 | val = BQ2589X_PUMPX_ENABLE << BQ2589X_EN_PUMPX_SHIFT; 484 | else 485 | val = BQ2589X_PUMPX_DISABLE << BQ2589X_EN_PUMPX_SHIFT; 486 | 487 | ret = update_bits(BQ2589X_REG_04, BQ2589X_EN_PUMPX_MASK, val); 488 | 489 | return ret; 490 | } 491 | 492 | int bq2589x::pumpx_increase_volt() 493 | { 494 | uint8_t val; 495 | int ret; 496 | 497 | val = BQ2589X_PUMPX_UP << BQ2589X_PUMPX_UP_SHIFT; 498 | 499 | ret = update_bits(BQ2589X_REG_09, BQ2589X_PUMPX_UP_MASK, val); 500 | 501 | return ret; 502 | } 503 | 504 | int bq2589x::pumpx_increase_volt_done() 505 | { 506 | uint8_t val; 507 | int ret; 508 | 509 | ret = read_byte(&val, BQ2589X_REG_09); 510 | if (ret) 511 | return ret; 512 | 513 | if (val & BQ2589X_PUMPX_UP_MASK) 514 | return BQ2589X_ERR; /* not finished*/ 515 | else 516 | return BQ2589X_OK; /* pumpx up finished*/ 517 | } 518 | 519 | int bq2589x::pumpx_decrease_volt() 520 | { 521 | uint8_t val; 522 | int ret; 523 | 524 | val = BQ2589X_PUMPX_DOWN << BQ2589X_PUMPX_DOWN_SHIFT; 525 | 526 | ret = update_bits(BQ2589X_REG_09, BQ2589X_PUMPX_DOWN_MASK, val); 527 | 528 | return ret; 529 | } 530 | 531 | int bq2589x::pumpx_decrease_volt_done() 532 | { 533 | uint8_t val; 534 | int ret; 535 | 536 | ret = read_byte(&val, BQ2589X_REG_09); 537 | if (ret) 538 | return ret; 539 | 540 | if (val & BQ2589X_PUMPX_DOWN_MASK) 541 | return BQ2589X_ERR; /* not finished*/ 542 | else 543 | return BQ2589X_OK; /* pumpx down finished*/ 544 | } 545 | 546 | int bq2589x::force_ico() 547 | { 548 | uint8_t val; 549 | int ret; 550 | 551 | val = BQ2589X_FORCE_ICO << BQ2589X_FORCE_ICO_SHIFT; 552 | 553 | ret = update_bits(BQ2589X_REG_09, BQ2589X_FORCE_ICO_MASK, val); 554 | 555 | return ret; 556 | } 557 | 558 | int bq2589x::check_force_ico_done() 559 | { 560 | uint8_t val; 561 | int ret; 562 | 563 | ret = read_byte(&val, BQ2589X_REG_14); 564 | if (ret) 565 | return ret; 566 | 567 | if (val & BQ2589X_ICO_OPTIMIZED_MASK) 568 | return BQ2589X_ERR; /*finished*/ 569 | else 570 | return BQ2589X_OK; /* in progress*/ 571 | } 572 | 573 | int bq2589x::enable_term(bool enable) 574 | { 575 | uint8_t val; 576 | int ret; 577 | 578 | if (enable) 579 | val = BQ2589X_TERM_ENABLE << BQ2589X_EN_TERM_SHIFT; 580 | else 581 | val = BQ2589X_TERM_DISABLE << BQ2589X_EN_TERM_SHIFT; 582 | 583 | ret = update_bits(BQ2589X_REG_07, BQ2589X_EN_TERM_MASK, val); 584 | 585 | return ret; 586 | } 587 | 588 | int bq2589x::enable_auto_dpdm(bool enable) 589 | { 590 | uint8_t val; 591 | int ret; 592 | 593 | if (enable) 594 | val = BQ2589X_AUTO_DPDM_ENABLE << BQ2589X_AUTO_DPDM_EN_SHIFT; 595 | else 596 | val = BQ2589X_AUTO_DPDM_DISABLE << BQ2589X_AUTO_DPDM_EN_SHIFT; 597 | 598 | ret = update_bits(BQ2589X_REG_02, BQ2589X_AUTO_DPDM_EN_MASK, val); 599 | 600 | return ret; 601 | } 602 | 603 | int bq2589x::use_absolute_vindpm(bool enable) 604 | { 605 | uint8_t val; 606 | int ret; 607 | 608 | if (enable) 609 | val = BQ2589X_FORCE_VINDPM_ENABLE << BQ2589X_FORCE_VINDPM_SHIFT; 610 | else 611 | val = BQ2589X_FORCE_VINDPM_DISABLE << BQ2589X_FORCE_VINDPM_SHIFT; 612 | 613 | ret = update_bits(BQ2589X_REG_0D, BQ2589X_FORCE_VINDPM_MASK, val); 614 | 615 | return ret; 616 | } 617 | 618 | int bq2589x::enable_ico(bool enable) 619 | { 620 | uint8_t val; 621 | int ret; 622 | 623 | if (enable) 624 | val = BQ2589X_ICO_ENABLE << BQ2589X_ICOEN_SHIFT; 625 | else 626 | val = BQ2589X_ICO_DISABLE << BQ2589X_ICOEN_SHIFT; 627 | 628 | ret = update_bits(BQ2589X_REG_02, BQ2589X_ICOEN_MASK, val); 629 | 630 | return ret; 631 | } 632 | 633 | int bq2589x::read_idpm_limit() 634 | { 635 | uint8_t val; 636 | int curr; 637 | int ret; 638 | 639 | ret = read_byte(&val, BQ2589X_REG_13); 640 | if (ret) 641 | { 642 | return ret; 643 | } 644 | else 645 | { 646 | curr = BQ2589X_IDPM_LIM_BASE + ((val & BQ2589X_IDPM_LIM_MASK) >> BQ2589X_IDPM_LIM_SHIFT) * BQ2589X_IDPM_LIM_LSB; 647 | return curr; 648 | } 649 | } 650 | 651 | bool bq2589x::is_charge_done() 652 | { 653 | uint8_t val; 654 | 655 | read_byte(&val, BQ2589X_REG_0B); 656 | val &= BQ2589X_CHRG_STAT_MASK; 657 | val >>= BQ2589X_CHRG_STAT_SHIFT; 658 | 659 | return (bool)(val == BQ2589X_CHRG_STAT_CHGDONE); 660 | } 661 | 662 | int bq2589x::init_device() 663 | { 664 | int ret; 665 | 666 | /*common initialization*/ 667 | 668 | disable_watchdog_timer(); 669 | 670 | ret = set_charge_current(2560); //2.5A 671 | 672 | return ret; 673 | } 674 | 675 | int bq2589x::detect_device(bq2589x_part_no *part_no, int *revision) 676 | { 677 | uint8_t data; 678 | if (read_byte(&data, BQ2589X_REG_14) == 0) 679 | { 680 | *part_no = (bq2589x_part_no)((data & BQ2589X_PN_MASK) >> BQ2589X_PN_SHIFT); 681 | *revision = (data & BQ2589X_DEV_REV_MASK) >> BQ2589X_DEV_REV_SHIFT; 682 | return BQ2589X_OK; 683 | } 684 | return BQ2589X_ERR; 685 | } 686 | 687 | int bq2589x::enable_max_charge(bool enable) 688 | { 689 | uint8_t val; 690 | uint8_t val1; 691 | int ret; 692 | 693 | if (enable) 694 | { 695 | val = BQ2589X_HVDCP_ENABLE << BQ2589X_HVDCPEN_SHIFT; 696 | val1 = BQ2589X_MAXC_ENABLE << BQ2589X_MAXCEN_SHIFT; 697 | } 698 | else 699 | { 700 | val = BQ2589X_HVDCP_DISABLE << BQ2589X_HVDCPEN_SHIFT; 701 | val1 = BQ2589X_MAXC_DISABLE << BQ2589X_MAXCEN_SHIFT; 702 | } 703 | 704 | ret = update_bits(BQ2589X_REG_02, BQ2589X_HVDCPEN_MASK, val); 705 | ret = update_bits(BQ2589X_REG_02, BQ2589X_MAXCEN_MASK, val1); 706 | 707 | return ret; 708 | } 709 | -------------------------------------------------------------------------------- /bq2589x.h: -------------------------------------------------------------------------------- 1 | #ifndef _BQ2589X_H 2 | 3 | #define _BQ2589X_H 4 | 5 | #include 6 | 7 | #include "bq2589x_reg.h" 8 | 9 | #define BQ25895_ADDR (0x6A); 10 | 11 | #define I2C_OK 0 //0:success 12 | #define I2C_ERR 1 13 | 14 | #define SCL_PIN 5 15 | #define SDA_PIN 4 16 | 17 | #define BQ2589X_OK 0 18 | #define BQ2589X_ERR 1 // ERR>0 19 | 20 | typedef enum bq2589x_vbus_type 21 | { 22 | BQ2589X_VBUS_NONE, 23 | BQ2589X_VBUS_USB_SDP, 24 | BQ2589X_VBUS_USB_CDP, /*CDP for bq25890, Adapter for bq25892*/ 25 | BQ2589X_VBUS_USB_DCP, 26 | BQ2589X_VBUS_MAXC, 27 | BQ2589X_VBUS_UNKNOWN, 28 | BQ2589X_VBUS_NONSTAND, 29 | BQ2589X_VBUS_OTG, 30 | BQ2589X_VBUS_TYPE_NUM, 31 | } bq2589x_vbus_type; 32 | 33 | typedef enum bq2589x_part_no 34 | { 35 | BQ25890 = 0x03, 36 | BQ25892 = 0x00, 37 | BQ25895 = 0x07, 38 | } bq2589x_part_no; 39 | 40 | 41 | 42 | class bq2589x 43 | { 44 | private: 45 | TwoWire *_wire; 46 | uint8_t _i2caddr; 47 | 48 | /* data */ 49 | public: 50 | bq2589x(/* args */); 51 | ~bq2589x(); 52 | int begin(); 53 | int begin(TwoWire *theWire); 54 | int begin(uint8_t addr); 55 | int begin(uint8_t addr, TwoWire *theWire); 56 | int read_byte(uint8_t *data, uint8_t reg); 57 | int write_byte(uint8_t reg, uint8_t data); 58 | int update_bits(uint8_t reg, uint8_t mask, uint8_t data); 59 | bq2589x_vbus_type get_vbus_type(); 60 | int enable_otg(); 61 | int disable_otg(); 62 | int set_otg_volt(uint16_t volt); 63 | int set_otg_current(int curr); 64 | int enable_charger(); 65 | int disable_charger(); 66 | int adc_start(bool oneshot); 67 | int adc_stop(); 68 | int adc_read_battery_volt(); 69 | int adc_read_sys_volt(); 70 | int adc_read_vbus_volt(); 71 | int adc_read_temperature(); 72 | int adc_read_charge_current(); 73 | int set_charge_current(int curr); 74 | int set_term_current(int curr); 75 | int set_prechg_current(int curr); 76 | int set_chargevoltage(int volt); 77 | int set_input_volt_limit(int volt); 78 | int set_input_current_limit(int curr); 79 | int set_vindpm_offset(int offset); 80 | int get_charging_status(); 81 | void bq2589x_set_otg(int enable); 82 | int set_watchdog_timer(uint8_t timeout); 83 | int disable_watchdog_timer(); 84 | int reset_watchdog_timer(); 85 | int force_dpdm(); 86 | int reset_chip(); 87 | int enter_ship_mode(); 88 | int enter_hiz_mode(); 89 | int exit_hiz_mode(); 90 | int get_hiz_mode(uint8_t *state); 91 | int pumpx_enable(int enable); 92 | int pumpx_increase_volt(); 93 | int pumpx_increase_volt_done(); 94 | int pumpx_decrease_volt(); 95 | int pumpx_decrease_volt_done(); 96 | int force_ico(); 97 | int check_force_ico_done(); 98 | int enable_term(bool enable); 99 | int enable_auto_dpdm(bool enable); 100 | int use_absolute_vindpm(bool enable); 101 | int enable_ico(bool enable); 102 | int read_idpm_limit(); 103 | bool is_charge_done(); 104 | int init_device(); 105 | int detect_device(bq2589x_part_no *part_no, int *revision); 106 | int enable_max_charge(bool enable); 107 | }; 108 | 109 | #endif 110 | -------------------------------------------------------------------------------- /bq2589x_reg.h: -------------------------------------------------------------------------------- 1 | #ifndef _BQ2589X_REG_H_ 2 | #define _BQ2589X_REG_H_ 3 | /* Register 00h */ 4 | #define BQ2589X_REG_00 0x00 5 | #define BQ2589X_ENHIZ_MASK 0x80 6 | #define BQ2589X_ENHIZ_SHIFT 7 7 | #define BQ2589X_HIZ_ENABLE 1 8 | #define BQ2589X_HIZ_DISABLE 0 9 | #define BQ2589X_ENILIM_MASK 0x40 10 | #define BQ2589X_ENILIM_SHIFT 6 11 | #define BQ2589X_ENILIM_ENABLE 1 12 | #define BQ2589X_ENILIM_DISABLE 0 13 | 14 | #define BQ2589X_IINLIM_MASK 0x3F 15 | #define BQ2589X_IINLIM_SHIFT 0 16 | #define BQ2589X_IINLIM_BASE 100 17 | #define BQ2589X_IINLIM_LSB 50 18 | 19 | /* Register 01h */ 20 | #define BQ2589X_REG_01 0x01 21 | #define BQ2589X_BHOT_MASK 0xC0 22 | #define BQ2589X_BHOT_SHIFT 6 23 | #define BQ2589X_BCOLD_MASK 0x20 24 | #define BQ2589X_BCOLD_SHIFT 5 25 | #define BQ2589X_VINDPMOS_MASK 0x1F 26 | #define BQ2589X_VINDPMOS_SHIFT 0 27 | 28 | #define BQ2589X_VINDPMOS_BASE 0 29 | #define BQ2589X_VINDPMOS_LSB 100 30 | 31 | /* Register 0x02 */ 32 | #define BQ2589X_REG_02 0x02 33 | #define BQ2589X_CONV_START_MASK 0x80 34 | #define BQ2589X_CONV_START_SHIFT 7 35 | #define BQ2589X_CONV_START 1 36 | #define BQ2589X_CONV_RATE_MASK 0x40 37 | #define BQ2589X_CONV_RATE_SHIFT 6 38 | #define BQ2589X_ADC_CONTINUE_ENABLE 1 39 | #define BQ2589X_ADC_CONTINUE_DISABLE 0 40 | 41 | #define BQ2589X_BOOST_FREQ_MASK 0x20 42 | #define BQ2589X_BOOST_FREQ_SHIFT 5 43 | #define BQ2589X_BOOST_FREQ_1500K 0 44 | #define BQ2589X_BOOST_FREQ_500K 0 45 | 46 | #define BQ2589X_ICOEN_MASK 0x10 47 | #define BQ2589X_ICOEN_SHIFT 4 48 | #define BQ2589X_ICO_ENABLE 1 49 | #define BQ2589X_ICO_DISABLE 0 50 | #define BQ2589X_HVDCPEN_MASK 0x08 51 | #define BQ2589X_HVDCPEN_SHIFT 3 52 | #define BQ2589X_HVDCP_ENABLE 1 53 | #define BQ2589X_HVDCP_DISABLE 0 54 | #define BQ2589X_MAXCEN_MASK 0x04 55 | #define BQ2589X_MAXCEN_SHIFT 2 56 | #define BQ2589X_MAXC_ENABLE 1 57 | #define BQ2589X_MAXC_DISABLE 0 58 | 59 | #define BQ2589X_FORCE_DPDM_MASK 0x02 60 | #define BQ2589X_FORCE_DPDM_SHIFT 1 61 | #define BQ2589X_FORCE_DPDM 1 62 | #define BQ2589X_AUTO_DPDM_EN_MASK 0x01 63 | #define BQ2589X_AUTO_DPDM_EN_SHIFT 0 64 | #define BQ2589X_AUTO_DPDM_ENABLE 1 65 | #define BQ2589X_AUTO_DPDM_DISABLE 0 66 | 67 | /* Register 0x03 */ 68 | #define BQ2589X_REG_03 0x03 69 | #define BQ2589X_BAT_LOADEN_MASK 0x80 70 | #define BQ2589X_BAT_LOAEN_SHIFT 7 71 | #define BQ2589X_WDT_RESET_MASK 0x40 72 | #define BQ2589X_WDT_RESET_SHIFT 6 73 | #define BQ2589X_WDT_RESET 1 74 | 75 | #define BQ2589X_OTG_CONFIG_MASK 0x20 76 | #define BQ2589X_OTG_CONFIG_SHIFT 5 77 | #define BQ2589X_OTG_ENABLE 1 78 | #define BQ2589X_OTG_DISABLE 0 79 | 80 | #define BQ2589X_CHG_CONFIG_MASK 0x10 81 | #define BQ2589X_CHG_CONFIG_SHIFT 4 82 | #define BQ2589X_CHG_ENABLE 1 83 | #define BQ2589X_CHG_DISABLE 0 84 | 85 | #define BQ2589X_SYS_MINV_MASK 0x0E 86 | #define BQ2589X_SYS_MINV_SHIFT 1 87 | 88 | #define BQ2589X_SYS_MINV_BASE 3000 89 | #define BQ2589X_SYS_MINV_LSB 100 90 | 91 | /* Register 0x04*/ 92 | #define BQ2589X_REG_04 0x04 93 | #define BQ2589X_EN_PUMPX_MASK 0x80 94 | #define BQ2589X_EN_PUMPX_SHIFT 7 95 | #define BQ2589X_PUMPX_ENABLE 1 96 | #define BQ2589X_PUMPX_DISABLE 0 97 | #define BQ2589X_ICHG_MASK 0x7F 98 | #define BQ2589X_ICHG_SHIFT 0 99 | #define BQ2589X_ICHG_BASE 0 100 | #define BQ2589X_ICHG_LSB 64 101 | 102 | /* Register 0x05*/ 103 | #define BQ2589X_REG_05 0x05 104 | #define BQ2589X_IPRECHG_MASK 0xF0 105 | #define BQ2589X_IPRECHG_SHIFT 4 106 | #define BQ2589X_ITERM_MASK 0x0F 107 | #define BQ2589X_ITERM_SHIFT 0 108 | #define BQ2589X_IPRECHG_BASE 64 109 | #define BQ2589X_IPRECHG_LSB 64 110 | #define BQ2589X_ITERM_BASE 64 111 | #define BQ2589X_ITERM_LSB 64 112 | 113 | /* Register 0x06*/ 114 | #define BQ2589X_REG_06 0x06 115 | #define BQ2589X_VREG_MASK 0xFC //0xFC 116 | #define BQ2589X_VREG_SHIFT 2 117 | #define BQ2589X_BATLOWV_MASK 0x02 118 | #define BQ2589X_BATLOWV_SHIFT 1 119 | #define BQ2589X_BATLOWV_2800MV 0 120 | #define BQ2589X_BATLOWV_3000MV 1 121 | #define BQ2589X_VRECHG_MASK 0x01 122 | #define BQ2589X_VRECHG_SHIFT 0 123 | #define BQ2589X_VRECHG_100MV 0 124 | #define BQ2589X_VRECHG_200MV 1 125 | #define BQ2589X_VREG_BASE 3840 126 | #define BQ2589X_VREG_LSB 16 127 | 128 | /* Register 0x07*/ 129 | #define BQ2589X_REG_07 0x07 130 | #define BQ2589X_EN_TERM_MASK 0x80 131 | #define BQ2589X_EN_TERM_SHIFT 7 132 | #define BQ2589X_TERM_ENABLE 1 133 | #define BQ2589X_TERM_DISABLE 0 134 | 135 | #define BQ2589X_WDT_MASK 0x30 136 | #define BQ2589X_WDT_SHIFT 4 137 | #define BQ2589X_WDT_DISABLE 0 138 | #define BQ2589X_WDT_40S 1 139 | #define BQ2589X_WDT_80S 2 140 | #define BQ2589X_WDT_160S 3 141 | #define BQ2589X_WDT_BASE 0 142 | #define BQ2589X_WDT_LSB 40 143 | 144 | #define BQ2589X_EN_TIMER_MASK 0x08 145 | #define BQ2589X_EN_TIMER_SHIFT 3 146 | 147 | #define BQ2589X_CHG_TIMER_ENABLE 1 148 | #define BQ2589X_CHG_TIMER_DISABLE 0 149 | 150 | #define BQ2589X_CHG_TIMER_MASK 0x06 151 | #define BQ2589X_CHG_TIMER_SHIFT 1 152 | #define BQ2589X_CHG_TIMER_5HOURS 0 153 | #define BQ2589X_CHG_TIMER_8HOURS 1 154 | #define BQ2589X_CHG_TIMER_12HOURS 2 155 | #define BQ2589X_CHG_TIMER_20HOURS 3 156 | 157 | #define BQ2589X_JEITA_ISET_MASK 0x01 158 | #define BQ2589X_JEITA_ISET_SHIFT 0 159 | #define BQ2589X_JEITA_ISET_50PCT 0 160 | #define BQ2589X_JEITA_ISET_20PCT 1 161 | 162 | /* Register 0x08*/ 163 | #define BQ2589X_REG_08 0x08 164 | #define BQ2589X_BAT_COMP_MASK 0xE0 165 | #define BQ2589X_BAT_COMP_SHIFT 5 166 | #define BQ2589X_VCLAMP_MASK 0x1C 167 | #define BQ2589X_VCLAMP_SHIFT 2 168 | #define BQ2589X_TREG_MASK 0x03 169 | #define BQ2589X_TREG_SHIFT 0 170 | #define BQ2589X_TREG_60C 0 171 | #define BQ2589X_TREG_80C 1 172 | #define BQ2589X_TREG_100C 2 173 | #define BQ2589X_TREG_120C 3 174 | 175 | #define BQ2589X_BAT_COMP_BASE 0 176 | #define BQ2589X_BAT_COMP_LSB 20 177 | #define BQ2589X_VCLAMP_BASE 0 178 | #define BQ2589X_VCLAMP_LSB 32 179 | 180 | /* Register 0x09*/ 181 | #define BQ2589X_REG_09 0x09 182 | #define BQ2589X_FORCE_ICO_MASK 0x80 183 | #define BQ2589X_FORCE_ICO_SHIFT 7 184 | #define BQ2589X_FORCE_ICO 1 185 | #define BQ2589X_TMR2X_EN_MASK 0x40 186 | #define BQ2589X_TMR2X_EN_SHIFT 6 187 | #define BQ2589X_BATFET_DIS_MASK 0x20 188 | #define BQ2589X_BATFET_DIS_SHIFT 5 189 | #define BQ2589X_BATFET_OFF 1 190 | 191 | #define BQ2589X_JEITA_VSET_MASK 0x10 192 | #define BQ2589X_JEITA_VSET_SHIFT 4 193 | #define BQ2589X_JEITA_VSET_N150MV 0 194 | #define BQ2589X_JEITA_VSET_VREG 1 195 | #define BQ2589X_BATFET_RST_EN_MASK 0x04 196 | #define BQ2589X_BATFET_RST_EN_SHIFT 2 197 | #define BQ2589X_PUMPX_UP_MASK 0x02 198 | #define BQ2589X_PUMPX_UP_SHIFT 1 199 | #define BQ2589X_PUMPX_UP 1 200 | #define BQ2589X_PUMPX_DOWN_MASK 0x01 201 | #define BQ2589X_PUMPX_DOWN_SHIFT 0 202 | #define BQ2589X_PUMPX_DOWN 1 203 | 204 | /* Register 0x0A*/ 205 | #define BQ2589X_REG_0A 0x0A 206 | #define BQ2589X_BOOSTV_MASK 0xF0 207 | #define BQ2589X_BOOSTV_SHIFT 4 208 | #define BQ2589X_BOOSTV_BASE 4550 209 | #define BQ2589X_BOOSTV_LSB 64 210 | 211 | #define BQ2589X_BOOST_LIM_MASK 0x07 212 | #define BQ2589X_BOOST_LIM_SHIFT 0 213 | #define BQ2589X_BOOST_LIM_500MA 0x00 214 | #define BQ2589X_BOOST_LIM_700MA 0x01 215 | #define BQ2589X_BOOST_LIM_1100MA 0x02 216 | #define BQ2589X_BOOST_LIM_1300MA 0x03 217 | #define BQ2589X_BOOST_LIM_1600MA 0x04 218 | #define BQ2589X_BOOST_LIM_1800MA 0x05 219 | #define BQ2589X_BOOST_LIM_2100MA 0x06 220 | #define BQ2589X_BOOST_LIM_2400MA 0x07 221 | 222 | /* Register 0x0B*/ 223 | #define BQ2589X_REG_0B 0x0B 224 | #define BQ2589X_VBUS_STAT_MASK 0xE0 225 | #define BQ2589X_VBUS_STAT_SHIFT 5 226 | #define BQ2589X_CHRG_STAT_MASK 0x18 227 | #define BQ2589X_CHRG_STAT_SHIFT 3 228 | #define BQ2589X_CHRG_STAT_IDLE 0 229 | #define BQ2589X_CHRG_STAT_PRECHG 1 230 | #define BQ2589X_CHRG_STAT_FASTCHG 2 231 | #define BQ2589X_CHRG_STAT_CHGDONE 3 232 | 233 | #define BQ2589X_PG_STAT_MASK 0x04 234 | #define BQ2589X_PG_STAT_SHIFT 2 235 | #define BQ2589X_SDP_STAT_MASK 0x02 236 | #define BQ2589X_SDP_STAT_SHIFT 1 237 | #define BQ2589X_VSYS_STAT_MASK 0x01 238 | #define BQ2589X_VSYS_STAT_SHIFT 0 239 | 240 | /* Register 0x0C*/ 241 | #define BQ2589X_REG_0C 0x0c 242 | #define BQ2589X_FAULT_WDT_MASK 0x80 243 | #define BQ2589X_FAULT_WDT_SHIFT 7 244 | #define BQ2589X_FAULT_BOOST_MASK 0x40 245 | #define BQ2589X_FAULT_BOOST_SHIFT 6 246 | #define BQ2589X_FAULT_CHRG_MASK 0x30 247 | #define BQ2589X_FAULT_CHRG_SHIFT 4 248 | #define BQ2589X_FAULT_CHRG_NORMAL 0 249 | #define BQ2589X_FAULT_CHRG_INPUT 1 250 | #define BQ2589X_FAULT_CHRG_THERMAL 2 251 | #define BQ2589X_FAULT_CHRG_TIMER 3 252 | 253 | #define BQ2589X_FAULT_BAT_MASK 0x08 254 | #define BQ2589X_FAULT_BAT_SHIFT 3 255 | #define BQ2589X_FAULT_NTC_MASK 0x07 256 | #define BQ2589X_FAULT_NTC_SHIFT 0 257 | #define BQ2589X_FAULT_NTC_TSCOLD 1 258 | #define BQ2589X_FAULT_NTC_TSHOT 2 259 | 260 | #define BQ2589X_FAULT_NTC_WARM 2 261 | #define BQ2589X_FAULT_NTC_COOL 3 262 | #define BQ2589X_FAULT_NTC_COLD 5 263 | #define BQ2589X_FAULT_NTC_HOT 6 264 | 265 | /* Register 0x0D*/ 266 | #define BQ2589X_REG_0D 0x0D 267 | #define BQ2589X_FORCE_VINDPM_MASK 0x80 268 | #define BQ2589X_FORCE_VINDPM_SHIFT 7 269 | #define BQ2589X_FORCE_VINDPM_ENABLE 1 270 | #define BQ2589X_FORCE_VINDPM_DISABLE 0 271 | #define BQ2589X_VINDPM_MASK 0x7F 272 | #define BQ2589X_VINDPM_SHIFT 0 273 | 274 | #define BQ2589X_VINDPM_BASE 2600 275 | #define BQ2589X_VINDPM_LSB 100 276 | 277 | /* Register 0x0E*/ 278 | #define BQ2589X_REG_0E 0x0E 279 | #define BQ2589X_THERM_STAT_MASK 0x80 280 | #define BQ2589X_THERM_STAT_SHIFT 7 281 | #define BQ2589X_BATV_MASK 0x7F 282 | #define BQ2589X_BATV_SHIFT 0 283 | #define BQ2589X_BATV_BASE 2304 284 | #define BQ2589X_BATV_LSB 20 285 | 286 | /* Register 0x0F*/ 287 | #define BQ2589X_REG_0F 0x0F 288 | #define BQ2589X_SYSV_MASK 0x7F 289 | #define BQ2589X_SYSV_SHIFT 0 290 | #define BQ2589X_SYSV_BASE 2304 291 | #define BQ2589X_SYSV_LSB 20 292 | 293 | /* Register 0x10*/ 294 | #define BQ2589X_REG_10 0x10 295 | #define BQ2589X_TSPCT_MASK 0x7F 296 | #define BQ2589X_TSPCT_SHIFT 0 297 | #define BQ2589X_TSPCT_BASE 21 298 | #define BQ2589X_TSPCT_LSB 0.465 //should be 0.465,kernel does not support float 299 | 300 | /* Register 0x11*/ 301 | #define BQ2589X_REG_11 0x11 302 | #define BQ2589X_VBUS_GD_MASK 0x80 303 | #define BQ2589X_VBUS_GD_SHIFT 7 304 | #define BQ2589X_VBUSV_MASK 0x7F 305 | #define BQ2589X_VBUSV_SHIFT 0 306 | #define BQ2589X_VBUSV_BASE 2600 307 | #define BQ2589X_VBUSV_LSB 100 308 | 309 | /* Register 0x12*/ 310 | #define BQ2589X_REG_12 0x12 311 | #define BQ2589X_ICHGR_MASK 0x7F 312 | #define BQ2589X_ICHGR_SHIFT 0 313 | #define BQ2589X_ICHGR_BASE 0 314 | #define BQ2589X_ICHGR_LSB 50 315 | 316 | /* Register 0x13*/ 317 | #define BQ2589X_REG_13 0x13 318 | #define BQ2589X_VDPM_STAT_MASK 0x80 319 | #define BQ2589X_VDPM_STAT_SHIFT 7 320 | #define BQ2589X_IDPM_STAT_MASK 0x40 321 | #define BQ2589X_IDPM_STAT_SHIFT 6 322 | #define BQ2589X_IDPM_LIM_MASK 0x3F 323 | #define BQ2589X_IDPM_LIM_SHIFT 0 324 | #define BQ2589X_IDPM_LIM_BASE 100 325 | #define BQ2589X_IDPM_LIM_LSB 50 326 | 327 | /* Register 0x14*/ 328 | #define BQ2589X_REG_14 0x14 329 | #define BQ2589X_RESET_MASK 0x80 330 | #define BQ2589X_RESET_SHIFT 7 331 | #define BQ2589X_RESET 1 332 | #define BQ2589X_ICO_OPTIMIZED_MASK 0x40 333 | #define BQ2589X_ICO_OPTIMIZED_SHIFT 6 334 | #define BQ2589X_PN_MASK 0x38 335 | #define BQ2589X_PN_SHIFT 3 336 | #define BQ2589X_TS_PROFILE_MASK 0x04 337 | #define BQ2589X_TS_PROFILE_SHIFT 2 338 | #define BQ2589X_DEV_REV_MASK 0x03 339 | #define BQ2589X_DEV_REV_SHIFT 0 340 | 341 | #endif -------------------------------------------------------------------------------- /examples/basic/basic.pde: -------------------------------------------------------------------------------- 1 | //basic example 2 | // by Spencer Chen 3 | // Created @date 2019-11-04 4 | // 5 | #include 6 | #include 7 | bq2589x mycharger; 8 | unsigned long last_change = 0; 9 | unsigned long now = 0; 10 | 11 | 12 | void setup() 13 | { 14 | Serial.begin(9600); 15 | Wire.begin(); 16 | mycharger.begin(&Wire); 17 | 18 | } 19 | 20 | void loop() 21 | { 22 | now=millis(); 23 | 24 | if (now - last_change > 5000) 25 | { 26 | 27 | last_change = now; 28 | 29 | mycharger.reset_watchdog_timer(); //reset watch dog 30 | Serial.printf("Battery voltage :%d \r\n", mycharger.adc_read_battery_volt()); // Read Battery voltage 31 | Serial.printf("System Voltage :%d \r\n", mycharger.adc_read_sys_volt()); // ReadSystem Voltage 32 | Serial.printf("Bus Volatge :%d \r\n", mycharger.adc_read_vbus_volt()); // Read Volatge 33 | Serial.printf("Temperature :%d \r\n", mycharger.adc_read_temperature()); // Read Temperature 34 | switch (mycharger.get_charging_status()) // charger status 35 | { 36 | case 0: 37 | Serial.print(" Charging status : Not Charging \r\n"); 38 | break; 39 | case 1: 40 | Serial.print(" Charging status : Pre-charge \r\n"); 41 | break; 42 | case 2: 43 | Serial.print(" Charging status : Fast Charging \r\n"); 44 | break; 45 | case 3: 46 | Serial.print(" Charging status : Charge Termination Done \r\n"); 47 | break; 48 | } 49 | Serial.printf("charger Current : %dA\r\n", mycharger.adc_read_charge_current()); // read charge current . 50 | Serial.printf("Idmp limit : %dA\r\n ", mycharger.read_idpm_limit()); //Dynamic Power Management current limit 51 | 52 | } 53 | 54 | } 55 | 56 | -------------------------------------------------------------------------------- /keywords.txt: -------------------------------------------------------------------------------- 1 | ####################################### 2 | # Syntax Coloring Map For bq2589x 3 | ####################################### 4 | 5 | ####################################### 6 | # Datatypes (KEYWORD1) 7 | ####################################### 8 | 9 | bq2589x KEYWORD1 10 | 11 | ####################################### 12 | # Methods and Functions (KEYWORD2) 13 | ####################################### 14 | 15 | basic KEYWORD2 16 | 17 | ####################################### 18 | # Instances (KEYWORD2) 19 | ####################################### 20 | 21 | ####################################### 22 | # Constants (LITERAL1) 23 | ####################################### 24 | 25 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | --------------------------------------------------------------------------------