Domme Batterijen - Spoof

Door Infant op zondag 30 december 2012 20:10 - Reacties (17)
Categorieën: Gemod / Gefix, Notebook: Accu's bouwen!, Views: 7.631

Wederom een post over notebook accu's. Dit en is een vervolg op de eerste, tweede en derde.

En de verplichte lijst met pdfjes:
SMBus v1.1 Specification
Smart Battery Data Specification v1.1
BQ2084 Datasheet
Atmega16U4 Datasheet
Elitebook 2730p Schema (Mediafire)

In de vorige deel heb ik wat geklaagd over hoe waardeloos er met accu's wordt omgegaan door mijn, en waarschijnlijk jouw notebook.

Mijn eerste notebook die ik elke dag gebruikte was een Compaq n410c. Om een treinreis van 6 uur een beetje verdraaglijk te maken was ik toen, een jaartje of 7 geleden, ook al lekker aan het prutsen en had ik een accu gemaakt van een half docking station, een zoot ducktape en dit er in:

Idioot grote accu van 20 stuks 103450

Het zijn 20 stuks 103450 cellen die samen rond de 130 Wh moesten voorstellen. Helaas snapte het bordje, wat ontworpen was voor 50Wh niet dat er ook twee keer zo veel energie in kon zitten, en was het na 50Wh dus afgelopen met de pret.

103450 is een vrij standaard maat voor wat plattere notebook accu's. Waar AA (14500) en AAA (10440) de meest voorkomende maten zijn, worden 18650s het meest gebruikt in notebooks, en zelfs de Model S gebruikt puur uit kosten overweging, een 40, 60 of 85kWh accu opgebouwd uit een enorme berg 18650 cellen.

Een AA en een paar 18650's

Die dingen worden wereld wijd namelijk toch al geproduceerd per miljarden voor in notebooks, dus waarom ook niet in je auto proppen. Het zijn dus echt gewoon dezelfde cellen, in een auto zitten er gewoon meer.

Het interessante is dat Tesla op zijn 85kWh batterij 8 jaar garantie geeft, of oneindig kilometers. Which ever comes first.

8 Jaar is een stuk beter dan de 0.5 tot 3 jaar die je bij je notebook gaat vinden.... waarom?

Dit is niet zo eenvoudig, maar in dit soort auto's komt het er op neer dat er erg nauwkeurig naar de cellen gekeken wordt door een stuk elektronica. Die houd de stroom en temperatuur in de gaten, en zorgt dat alle cellen in balans zijn.

Wat verder voor de levensduur van belang is, is dat ze niet volledig op en ontladen worden. Meestal wordt de cel in zo'n auto tussen 40 en 80% van zijn energie capaciteit benut.

Er zijn 1001 onderzoekjes te vinden, waar tientallen cellen ontladen en opgeladen worden, dag in dag uit. De cellen die steeds maar 40% ontladen worden zijn na 200 cycli nog prima in orde, en hebben nog 99% van hun capaciteit. De cellen die volledig opgeladen en ontladen worden hebben nog maar 80% of erger.

Door te zorgen dat de cellen alleen in hun, vanuit levensduur oogpunt gezien, gunstige gebied gebruikt worden, kan zo'n ding echt langer dan 8 jaar mee gaan.
Balans Dag
Hoe houd zo'n ding nou bijvoorbeeld cel balans in de gaten? Het makkelijkst om het begrip cel onbalans een beetje in te zien, vind ik het volgende:

Hieronder zien we 3 cellen in serie. De grote draad bovenin is de plus, de draad onderin is de min. De spanning van de 3 cellen tellen in serie bij elkaar op. Als ze allen 4 Volt zijn, hebben we in totaal 12 Volt.

Als we in een serie als deze stroom vragen of aan de cellen leveren, moet deze stroom door elke cel heen. Stel nou dat de cellen uit balans zijn:

3 Serie Cellen

De middelste cel is voor 60% vol, de rest 80%. In dit voorbeeld is de tweede cel leeg als we er nog 60% lading uit halen. De rest heeft dan nog 20% over.

De cellen die voller zijn worden dus iets minder belast, namelijk van 80% naar 20%, t.o.v. 60% naar 0%. De lege cel wordt dus eigenlijk ongunstiger gebruikt dan de rest, en op deze manier is een kleine onbalans zelf versterkend. Dat wil zeggen, hoe vaker we hem gebruiken, des te sneller zal de middelste cel slijten ten opzichte van de rest.

Dit is het simpelste voorbeeld wat ik kan bedenken. Er zijn nog veel meer andere problemen die zich voordoen, zoals een enorme temperatuur afhankelijkheid. De meeste factoren hebben versterkend effect hebben op de cel onbalans.
Laden
De meest gebruikte laad strategie voor een cel is CC/CV. Dit betekend Constant Current / Constant Voltage en is vrij eenvoudig:

Als een cel leeg is, laad je er een constante hoeveelheid stroom doorheen lopen.(CC). Op een gegeven moment stijgt de spanning in de cel tot een boven grens, waarna je deze spanning gelijk houd en de stroom vanzelf afneemt (CV):

Bron: Battery University
Charge Profile Battery University

De meest goedkope laders doen dit, en de lader in mijn notebook in theorie ook. Ik heb een accu die nog goed is (voor de afwisseling) aan m'n logger gehangen tijdens het laden, en dat levert de volgende plotjes op: (klik voor groot)

Laadgedrag van een orginele 44Wh HP accu (300 cycli, 3 jaar, 25% wear)Orginele HP accu voor een 2730p. Opgeladen van volledig leeg.

De horizontale as is het aantal seconden vanaf het begin van het loggen. Vertikaal is milliVolt, milliAmpere, milliAmpereuur, percentage of graden celcius (waar toepasbaar).

Nou, dit ziet er allemaal vrij prima uit. Het duurt een uur om het ding van 0% naar 80% te laden, en nog een uur om de resterende 20% bij te vullen.
De stroom en spanning grafiek lijken erg veel op de grafiek erboven.

Bij de stroom valt wel iets op, namelijk dat na een uur (c.a. 3700 seconden) de grafiek in stapjes afloopt inplaats van netjes in een lijntje. En aan het einde is het ineens afgelopen. Waarom is dat?
Als je namelijk gewoon een accu aan een lader hangt, krijg je eigenlijk automatisch een vloeiende grafiek zoals degene uit battery university, en niet een ding wat in stapjes afneemt.
Hier gaan we aan het eind nog eens naar kijken.

Het SMBus protocol is een vrij mooi protocol. Als de accu aan een lader gehangen wordt, of gewoon aan een systeem, kan hij d.m.v. status codes aangeven aan alles hoe het met de accu gesteld is. Op pagina 28 staat een lijstje van alarm codes. De batterij kan mater op de bus worden, en zo aan de lader vertellen dat het serieus fout gaat, en dat de lader moet stoppen.
Op pagina 36 staat een ander ding wat de batterij de bus op kan slingeren, namelijk charging current en charging voltage.
De accu kan dus gewoon tegen de lader zeggen: Ik wil 2 Ampere hebben, en maximaal 12 Volt. En dan krijg je dus het eerste uur 2 Ampere, en daarna gaat de lader niet verder dan 12 Volt. Prachtig. Zo wil je het hebben.

Maar.... hoe heeft HP het geïmplementeerd? Herinner je je dit tabelletje, waarin ik al het dataverkeer wat voorbij kwam gemarkeerd heb? Het eerste commando daarin, 0x03, is in blauw(achtig) gemarkeerd, en wijkt af van de rest.

De meeste waardes worden namelijk uit de accu opgevraagd, maar status wordt eerst weg geschreven en daarna weer opgevraagd.

code:
1
2
1 1 16  3  0 60 
2 1 16  3 17 C1 60



Op pagina 36 van de BQ2084 datasheet staat wat dat voor een gevolgen heeft. 0x60 vertaalt namelijk naar:
Disable Alarm Broadcast
Disable Charging Broadcast

En als beschrijving: "When set, the bq2084-V143 does not master the
SMBus, and AlarmWarning() messages are not sent to the SMBus host and the smart battery charger"


Dit betekend dat de accu nog steeds kan zeggen hoeveel stroom en spanning hij wil hebben. Hij kan ook zeggen: "Help! Ik wordt teveel opgeladen!"
Maar er is niemand die dat gaat horen.

Deze waardes zijn wel op te vragen, en dat wordt ook gedaan. Charging Current en Charging Voltage worden één keer opgevraagd als je de accu er in doet, en daarna op compleet willekeurige tijdstippen met soms wel 10 minuten er tussen.

....

Laat deze informatie even bezinken.

....

Waarom! Waarom!

Nu besluit de lader zelf, gebaseerd op de totale spanning, of er opgehouden moet worden met laden. Terwijl er een heel protocol in place is, die de accu in staat stelt om te zeggen wat hij wil hebben. WHY FOR THE LOVE OF GOD!

Maar okee, it could be worse.

Bij deze nog vrij goede in balans-zijnde accu, geeft dat na de 80% dus deze plaatjes voor stroom en cel spanning. (Ingezoomd op bovenstaande grafieken:)
Laadgedrag van een orginele 44Wh HP accu (300 cycli, 3 jaar, 25% wear) Ingezoomd

Op zich is het niet al te erg. Hij word in ieder geval niet over geladen. Maar erg netjes is anders.

Nou wil ik geen 100 Euro aan een nieuwe HP accu uitgeven elk jaar. Gewoon, uit principe.

Gelukkig kunnen bepaalde Aziaten deze accu's voor c.a. 50 Euro op de markt krijgen, i.p.v. de c.a. 100 Euro die HP er voor vraagt. Het gaat hier dan om een 3600 mAh accu i.pv. 4000 mAh. Dat je iets minder krijgt... okee. Maar de capaciteit is duidelijk niet het enige waar op bespaard is. De 3 stuks TI chipjes die er in zitten zijn ook al makkelijk een eurootje of 20.

Dat kan goedkoper.

Eens kijken wat een Chinese accu voor een plotjes produceert:

Laadgedrag van een Chinese Fop accu.

En weer ingezoomd:

Laadgedrag van een Chinese Fop accu. Ingezoomd
Pijnlijk.

Het eerste wat opvalt is dat de temperatuur sensor compleet weg bezuinigd is. En gelijk hebben ze. Die informatie wordt toch genegeerd, dus waarom zou je het er dan in doen?

Ten tweede weet deze accu eigenlijk op geen enkel tijdstip wat er nou precies aan de hand is. De metingen zijn zo on-nauwkeurig en all over the place dat het een wonder is dat deze dingen überhaupt werken.

Een van de cellen komt volgens de metingen steeds iets boven de 4.35 Volt uit. Dit is exact het gebied waarboven een cel gaat overladen met thermal runaway als mogelijk gevolg.

Een fatsoenlijke accu beveiliging had nu gezegd dat het echt te gek wordt, en had zichzelf moeten ontkoppelen. Zelfs al gaat het goed, deze informatie zit er in als beveiliging. Als de informatie zegt:

"Ik ga ontploffen!"

Dan neem je het zekere voor het onzekere, en houd je op met laden.

Bij de HP accu zie je dat de cel meet waarden misschien 2-5 millivolt ruis vertonen. Zelfs met een slechte absolute nauwkeurigheid zou je dan nog goed veilig zitten.

De absolute nauwkeurigheid in deze Chinese accu kan ik niks over zeggen, gezien ik die vergelijking nog niet gemaakt heb. Maar met een ruis niveau van 150 millivolt kan je in ieder geval niet fatsoenlijk bepalen of alles nog goed gaat, zelfs al zijn je waardes spot-on.

Tot zo ver een kleine inzage in het laad gedrag van notebook accu's.

Gewapend met gelogd dataverkeer, en een zoot datasheets is het nu tijd om zelf accu te gaan spelen.
Spoof Spoof
Spoofing, is jezelf voordoen als iets of iemand anders. En je ziet hem natuurlijk al aankomen, de Atmega gaat doen alsof hij een batterij is. Een dooie, om mee te beginnen. En daarna, wellicht een werkende.

Wat de notebook bij het inprikken van de accu doet, is een hele tabel aan gegevens opvragen, en daarna vraagt hij af en toe zo eens wat data op. Willekeurig.

Wat de laptop dus normaal aan de batterij vraagt, gaat hij nu aan een Atmega vragen. En die gaat dan gewoon alles wat een accu zou zeggen, terug zeggen. Zo simpel.

Zodoende heb ik alle commando's in een lijstje gezet. Alle data die door de datas niffer verzameld is, is ook in de Atmel gepropt en op die manier lijkt het alsof de notebook met een BQ2084 aan het praten is.

Bij het opvragen van de meet gegevens, zoals spanning, stroom, temperatuur etc. worden steeds twee bytes opgevraagd. Bij de ManufacturerName en ManufacturerData wordt een hele rits tekens, met een variabele totale lengte opgevraagd. Een stukje van de code ziet er dan zo uit:

C: Interrupts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
uint8_t getbyte(uint8_t which, uint8_t cmd){
    uint8_t ret = 0;
    switch(cmd){
        case CMD_VOLTAGE:{
            if (which == HI_BYTE)
                return 0x40;
            else
                return 0xA8;
            break;
        }
        /* 
         Hiertussen nog een berg aan andere states.
        */
        case CMD_MANUFCT_NAME:{
            // Lo returns string len, the rest the string.
            if (which == LO_BYTE){
                ret_str_ptr = 0;
                return MANUFCT_NAME_LEN;                
            }else{
                ret = manufct_name[ret_str_ptr];
                if (ret_str_ptr < MANUFCT_NAME_LEN)
                    ret_str_ptr++;
                return ret;
            }
            break;
        }
    return 0;
}


Als de spanning wordt opgevraagd, geeft hij een vaste waarde terug, en dat geldt ook voor stroom, temperatuur en noem het maar op.
Al deze waardes zijn ooit voorbij gekomen uit een accu die niet echt wou kalibreren, maar zich wel gewoon aanmeld. Dus met deze waardes moet het werken.

Na veel gepielemuis, een berg leed wat ik jullie allemaal zal besparen, vertelt de notebook eindelijk dat er een accu gevonden is:

Een defecte accu

Jeeej!

Vervolgens heb ik alle vaste waardes omgetoverd tot variabele, en dan kun je wat gaan experimenteren.

Als ik bijvoorbeeld zeg dat de cellen en spanning 0 Volt hebben, dan wordt de accu niet herkend door het systeem. Hetzelfde geld voor belachelijk hoge spanningen.

Maar getalletjes die niet optellen, of niet kloppen, maar wel binnen de norm vallen, worden goed gekeurd, en de accu wordt netjes herkend.

Na wat waardes invullen, en hele stukken datasheet implementeren is deze Atmel nu een week oud.
Er zit dus nog garantie op! O ja!

Verder geeft hij aan de notebook door dat hij tot 1337 mAh opladen, en verder zijn alle cellen netjes 3700mV, maar de totale spanning is 12 Volt.

Gespoofte accu. Alles is okee!

En dit werkt! Het wordt allemaal goed gekeurd, en hij meld zich als semi-defecte accu aan.

Als je nu een willekeurige echte accu aan de plus en min van de connector hangt, een lood accu bijvoorbeeld, denkt de notebook dat alles okee is. Immers, dit verteld de accu. Ookal is de spanning compleet anders.

Het stukje analoge elektronica in de notebook, de battery selector ziet inderdaad een spanning, en het moment dat ik de stekker er uit trek, wordt er stroom uit de externe accu gezogen.

Ha! Fooled you! Maar hij doet het wel.

Helaas zal Windows nooit met een voorspelling komen hoe lang de accu nog mee gaat, want de 'accu' verteld telkens dat hij 100% vol is, of eigenlijk dat er nog 1337 mAh in zit... de hele tijd.
Toch vind de notebook dit niet erg, en gaat hij gewoon door tot de accu echt leeg is.

Wat ook jammer is, is dat ondanks dat ik om een laadstroom en spanning vraag, er niet opgeladen wordt. Dus zo gemakkelijk is de lader niet te foppen. Ergens diep in de lader gaat een lampje branden: "Wait a minute! This isn't right! Something is wrong here...."

Dit werkt!

Mijn grootste probleem is nu getackeld. Namelijk, dat de notebook de tweede accu niet wou ontladen.

Maar ik ben er nog steeds niet. De huidige opstelling (zie plaatje) is verre van portable. Het zou ook wel leuk zijn als de notebook hem kan opladen, en op zich is een indicatie van hoe lang het zaakje mee kan gaan ook wel aardig.

In het tweede artikel begon ik met een versimpeld schema, waar de accu als bijzaak ook in getekend zat. Laten we daar nu eens wat verder naar gaan kijken.
Wat moet een batterij doen?
Blokschema van een specifieke HP accu

Degene die ik heb open gepeuterd, ziet er in schema vorm, ongeveer zo uit. Het enige wat ik er niet in heb gezet, is de temperatuur sensor.

Je zit 3 IC's. Er zijn ook accu's met 2 of maar 1 IC, maar deze had er 3. Het IC links boven doet protection, en dat noemen ze 3rd level protection. Als alle andere IC's naar de klote zijn, of iemand zet per ongeluk 220 Volt op de accu polen, is het zijn taak om de fuse door te branden. Dat is het enige wat hij kan doen. Als hij dat gedaan heeft, is het schluss. Afgelopen.
De accu gaat het dan ook nooit meer doen. Er wordt een status bitje in het 2e IC weg gezet, zodat zelfs als je de fuse vervangt, de notebook hem nog steeds als defect verklaard, en voor altijd met rust laat.

Het 2e IC daar onder, kijkt net als het de eerste naar de cel spanningen. En tevens naar de stroom die de accu uit loopt. Dit meet hij door naar de spanning over de shunt weerstand ondering te kijken. Hoe hoger deze spanning, hoe meer stroom er loopt.
Als de cellen te vol of leeg raken, of de stroom wordt te veel... kan dit IC de twee mosfetjes Q1 en Q2 uit zetten, waardoor de accu in feite los gekoppeld wordt.

En het IC helemaal rechts heeft als taak te zorgen dat de andere 2 IC's niks hoeven te doen. Als dat namelijk zo is, gaat het goed. En dat wil je doorgaans hebben. Dit IC kijkt ook zelf naar de stroom, maar vraagt de rest van de variabelen zoals individuele cel spanningen op uit het 2e IC. En als de notebook er om vraagt, geeft dit IC ze dus door.

Dat was het eigenlijk wat safety betreft. Meer hoeft de accu niet te doen. Balanceren had leuk geweest, maar het hoeft niet.

Het enige wat hij verder moet doen, is de gemeten stroom over de tijd integreren, en dat geeft dan de capaciteit. En dan, na een jaartje, moet hij stuk gaan zodat jij bij HP aan kan gaan kloppen en zegt:

"Doet het niet meer. Is stuk. Moet nieuwe!"

En dan wijst HP naar het verlopen garantie stickertje, en verwijst je door naar de webwinkel.

Behalve het stuk-ga gedeelte, heb ik de rest kwa hardware grotendeels nog ergens op een bordje slingeren die ik ooit voor iemand gemaakt heb.
Met een klein beetje re-wiring, wat gepruts en gesnoei, kan dat best wel eens dienst gaan doen als accu-protection-test-ding....

Ik noem het: Spoofy.
Spoofy
Spoofy. Een echte nep accu.

Dit ding heeft eigenlijk alles wat de Chinese HP accu ook heeft, namelijk alles wat een originele HP accu ook heeft, op een temperatuur sensor na. (Die paste er niet meer op.)
Verder gewoon minder en vooral goedkopere IC's. Het kan ook niet balanceren, maar alleen toekijken hoe je cellen mishandeld worden en er iets aan doen als het te ver gaat.

Het boogje bij de gele draad is de meet weerstand, of in ieder geval een stuk koper wat daar op lijkt.
Aan de onderkant zitten vier (twee parallel) P-channel mosfets. Het hadden er ook twee mogen zijn, maar het zijn er 4.

Er zat een spoel in het midden, maar die is vervangen door een stuk draad.

Verder zit er een van de goedkopere Atmels op die je kunt vinden, een Atmega88PA. Het fijne hieraan vind ik dat hij:
1: Goedkoop is.
2: Altijd doet wat ik zeg.
3: Blijft werken als ik hem mishandel.

Verder zit er een zoot weerstandjes op, wat rommel om alles aan te sturen en te meten, en te zorgen dat het aan blijft.

Met een kleine aanpassing loopt de accu-spoof code hier prima op, en is het tijd om wat logica te gaan introduceren:
Meten is... benaderen
Deze Atmega is verre van ideaal, en kan van heel veel dingen, heel weinig. Het heeft TWI erin zitten, dus het kan met de notebook praten.
Er zitten 10-bit ADCs op, met een vrij brakke nauwkeurigheid. En ze zijn ook nog vrij traag.
Hij kan zonder kristal lopen, maar dan tot maar 8MHz.

Gelukkig kan je er toch wat mee. Het accu loggen leerde ons dat er toch maar één keer per seconde data opgevraagd word. Dat geeft ons een hele seconde de tijd, om gegevens te verzinnen. Dat is vrij lang.

Als eerste worden de cel spanningen gemeten, door middel van een paar weerstands delingen:
Cels spanningen over weerstanden

Omdat de Atmega er niet echt vrolijk van wordt als je hem met comma getallen laat rekenen, heb ik de weerstand waardes zo gekozen, dat hij ze makkelijk van elkaar kan af trekken om zo de individuele cel spanningen te verkrijgen. Dit maakt het ietsje minder nauwkeurig als zou kunnen, maar ach.. je moet iets.

V1 is de onderste cel, en komt als een kwart van zijn spanning (100k+33k/33k) binnen op een analoge ingang. Dat zou maximaal 4.2 Volt * 0.25 = 1.05 Volt zijn.
De tweede spanning is dus 2.05V en de 3e, wat tevens de uitgangs spanning is, is dan 3.15 Volt. Allemaal binnen de grens van 5V die maximaal op de ADC mag komen te staan.

Stel dat alle cellen exact 3.7 Volt zijn. Het getal waar de microcontroller dan mee moet gaan werken, is (1024/5) * (3.7/4). Namelijk het aantal bits, gedeeld door de referentie, maal de spanning op de ADC pin.
Dat zou 189 als getal opleveren.

Maar, uiteindelijk moet de Atmega het getal 3700 tegen de notebook gaan vertellen. Ongeveer 19,6 keer zo groot.

Om dit op te lossen doet hij een hele berg metingen. Die telt hij allemaal bij elkaar op, en deelt hij door een macht van 2, dit kan namelijk wel heel simpel. Op deze manier heb je niet alleen een simpelere berekening gedaan, maar de meting is ook nauwkeuriger geworden.

Als je er voldoende doet, nu iets van 180 ofzo, wordt in ieder geval het getal wat je produceert nauwkeurig genoeg. Het zou nu op 13 bits komen, en dat betekend dat je waardes op een millivolt nauwkeurig kunt representeren. (Ik zeg niet dat ze ook zo nauwkeurig zijn, maar de stapgrootte is nu klein genoeg.)

De stroom meting heeft een ander berijk, waardoor ik een ander aantal metingen moet doen. Het is een oplossing for now, maar verre van ideaal.

C: ADCTask
1
2
3
4
5
6
7
8
9
10
11
12
void ADCTask(){
    if (adc_reads < READMAX_V){
        vbat += (uint32_t)ADC_read(VBAT);
        v1 += (uint32_t)ADC_read(V1);
        v2 += (uint32_t)ADC_read(V2);
    }
    if (adc_reads < READMAX_I){ 
        iin += (uint32_t)ADC_read(IIN);
        iref += (uint32_t)ADC_read(IREF);
    }
    adc_reads++;
}


Zoals je ziet, wordt alles gesommeerd. Als hij alle metingen genoeg gedaan heeft, worden alle waardes die over de SMBus opgevraagd kunnen worden ge-update:

C: Update
1
2
3
4
5
6
vbat = (vbat >> 3);
    v1 = (v1 >> 3);
    v2 = (v2 >> 3);
    val_voltage = (uint16_t)vbat;   
    val_cell1 = (uint16_t)(v1);
    val_cell2 = (uint16_t)(v2-v1);



De stroom wordt op een soortgelijke manier gedaan, maar omdat de stroom ook negatief mag worden, gaat dit net ietsje anders.

Verder is er een functie die telkens kijkt of de spanning en stroom binnen bepaalde grenzen blijven, en als dat niet zo is... worden de FET's uit gezet:

C: Safety
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void do_safety(){
    uint8_t flag = 0;       
    if ((val_current > 4000) || (val_current < (-4000))){
        flag = 1;
    }
    if ((val_current > 6000) || (val_current < (-6000))){
        flag = 1;
        safety_cnt +=5;
    }
    if ((val_cell1 > 4300) || (val_cell1 < 2800)){
        flag = 1;
    }
    if ((val_cell2 > 4300) || (val_cell2 < 2800)){
        flag = 1;
    }
    if ((val_cell3 > 4300) || (val_cell3 < 2800)){
        flag = 1;   
    }
    if (flag)
        safety_cnt++;
    if (safety_cnt> SAFECNT_MAX){
        BatteryOff();
    }
}


Al deze dingen worden grofweg 60 keer per seconde uitgevoerd. Als er dus echt te veel stroom loopt, 6A i.p.v. de 4A, moet hij sneller besluiten dat het afgelopen is.
Dit heb ik er zo ingezet, omdat de notebook wel eens heel kort een pulsje van veel stroom trekt, als je ineens het scherm aan doet, en de cpu 100% belast.

Hij kan nu gewoon netjes de halogeen lamp op starten, en als je hem kort sluit, gaat hij netjes uit. Precies wat een HP accu ook doet.

En als laatste willen we van de lader een stroom en spanning krijgen. Deze staat er nu ingesteld op 12500mV en 1500mA. En dan zoekt de lader zelf maar uit wat hij daar mee doet.

Tot mijn verbazing, werkt het. Hij laad op!

Ook de notebook vind dat het werkt.

Er wordt dus eerst continu 1500 mAh de accu in geperst, tot de door mij ingestelde grens van 12.5 Volt bereikt is. Daar gaat de lader niet overheen, met als gevolg dat de stroom langzaam afneemt.

Door hem in serie met mijn voltmeter te zetten, heb ik de stroom rond de c.a. 10 mA nauwkeurig kunnen kalibreren. Dat chinese ding zit er ook steeds 400 mA naast, en dat ding werkt.. dus 10mA zal de hardware niet wakker van liggen.

Nu heb ik drie oude celletjes aan elkaar geplakt, de spoof-accu een capaciteit van 0 gegeven, en het zaakje aan de lader gehangen. De totaal uit de hand gelopen opstelling ziet er dan zo uit:

Accu, accu-poofer, sniffer en algehele laad bende

En produceerde de volgende laad plotjes:
Laadgedrag van 3 cellen aan Spoofy.

En weer ingezoomd:
Laadgedrag van 3 cellen aan Spoofy. Ingezoomd.

Ja, de SOC en temperatuur is nog steeds constant. En het stukje code wat de mA's bij elkaar optelt verkeerde hier nog in een test-fase, en is stuk. Het gaat hier om de stroom en spanning.

Mijn multi meter kan de cel spanning maar in 2 decimalen weergeven. Toch, als je ze vergelijkt over het hele bereik, wijkt deze meting steeds niet meer dan 20mV af van wat de multi meter aangeeft.

Nu al, zou ik willen zeggen dat het een stuk beter is als de chineese accu van vijftig ballen. Het ziet er eigenlijk niet veel slechter uit als de orginele HP accu. En ik ben net begonnen!
En .... nu!!!???
Nu, kan je eigenlijk alles doen wat je wilt:

Lood accu's opladen.
Lood accu's ontladen.
De cellen vervangen, en de capaciteit instellen.
Er uberhaupt geen cellen in doen, maar hem gewoon aan een willekeurige spannings bron hangen.
Zonnepaneel eraan hangen.
Als tussen bordje gebruiken voor HP accu's die de weg kwijt zijn.
LiFePO4 cellen erin stoppen.
NiCd cellen erin stoppen.
....

Verzin het maar. Het kan. Je kunt een andere notebook van stroom voorzien, met een andere notebook. Je kunt je auto accu druppel laden... vanuit je notebook. Je kunt een mengtafel poweren... vanaf je notebook. Het ding is er namelijk voor gemaakt, alleen niemand heeft het gedaan.

Nu ik wat heb om mee te testen, ga ik daar wat mee aan de slag, en het hele ding een stuk kleiner maken. Het bordje is nu voor meer dan de helft bezaaid met dingen die niet nodig zijn, en dit kan makkelijk naar een formaat wat ik in een accu kan proppen.

Omdat de communicatie wel enigsinds aan een standaard voldoet, werkte dit ding op van alles: Een n600c van 1000 jaar oud, een TC1100 tablet PC, een nx7400. Die dingen zitten c.a. 10 jaar uit elkaar.

Ik denk dat ik dan iets ga maken, waar ik gewoon dit soort intens goedkope cellen aan kan hangen. 4400 mAh zou dan namelijk nog geen 20 Euro kosten. En wat ever dat wordt, ga ik hier met jullie delen.

Mocht iemand in de tussentijd meer in detail willen weten hoe dit ding werkt (Ik heb lang niet alles uit kunnen leggen.) code wil zien, of wil weten waarom iets is zoals het is. Laat maar wat horen. Ik sta open voor ideeën.

Domme Batterijen - Verkeer(de)informatie

Door Infant op zondag 23 december 2012 17:32 - Reacties (14)
Categorieën: Gemod / Gefix, Notebook: Accu's bouwen!, Views: 8.741

Ook deze post gaat weer over notebook accu's(of batterijen, ik haal ze willekeurig door elkaar), en is een vervolg op de eerste en tweede.

Ik heb een frumsel gemaakt om het verkeer tussen notebook en accu te kunnen afluisteren. Ik laat in deze deze post ziet wat je daar zoal mee kan doen.
Links
De alsmaar groeiende lijst van pdfjes:
SMBus v1.1 Specification
Smart Battery Data Specification v1.1
BQ2084 Datasheet
Atmega16U4 Datasheet
Elitebook 2730p Schema (Mediafire)
Boem! Uit
Er zijn op het internet aardig wat mensen te vinden die wel eens een notebook batterij uit elkaar gesloopt hebben.
Wat ze meestal doen is de kapotte cellen vervangen door nieuwe, voor een bedrag van veel minder dan een nieuwe accu, en daarmee hopen ze klaar te zijn.
Ik ben er weinig tegen gekomen die vervolgens weer een zo goed als nieuwe accu hadden. Ze lopen allemaal tegen het probleem aan:
  • Accu doet nog steeds niks.
  • Hij wil niet kalibreren.
  • Bij 50% valt de notebook uit.
  • Capaciteit is wel toegenomen, maar nog steeds niet wat je verwacht.
  • Hij laad niet volledig op.
Op tweakers zijn er misschien wel twee hele topics te vinden waar accu's uit elkaar gehaald worden. Er zijn wel honderden topics te vinden waar mensen een probleem uit bovenstaande lijst melden.

Het fundamentele probleem bestaat uit twee dingen:
1: 'Smart Batteries' zijn dom.
2: De standaard is te vaag.

Deze gast is een van de weinige die ook cellen vervangen heeft, en vervolgens door het moeizame proces van chipjes los solderen en flashen is gegaan.
En bij 'Further observations en rants' verteld hij precies de twee bovengenoemde punten.

Accu informatie wordt door een Host IC uit de accu gehaald, en beland in je BIOS. Zo staat daar bijvoorbeeld in:

State of Charge: Een getal tussen de 0 en 100. Je raad het al. Dat is gewoon het percentage peut wat er nog in je accu zit.
Battery Voltage: De totale spanning van de accu.
Remaining Capacity: De hoeveelheid mAh of mWh die nog in de accu zit.
Full Charge Capacity: Hoeveel er in kan, ook in mAh of mWh.
Design Capacity: Hoeveel er in kon toen hij nieuw was.

Al deze waardes komen uit je batterij wandelen. Ze worden aan de accu gevraagd, en die verteld ze ook keurig netjes terug.
Maar... neem nou bijvoorbeeld State of Charge. Die kunnen we zelf ook wel uitrekenen, namelijk:
(100% / Full Charge Capacity)*Remaining Capacity.

Wear level is een soortgelijk sommetje: (100% / Design Capacity)*Full Charge Capacity.

Gezien al deze waardes bij mij door een ongedocumenteerd chipje, wat achter duizend lagen van NDA's zit verstopt, worden uitgelezen... is het volledig onduidelijk wat er nou precies met deze waardes gebeurt.
En dat is dus probleem 2.

Er is geen standaard die fatsoenlijk zegt wat een OS of een BIOS met accu waardes moet doen. Als de accu zegt: "Yo, volgens mijn teller ben ik leeg...."
Dan zegt het BIOS: "Nou, dan ga ik uit. Doei!"
En boem. Je notebook is uit.

Wat je zou willen, is dat de BIOS wat intelligenter is en het volgende zegt: "Is dat wel zo? Ben je echt leeg? De spanning is nog meer dan voldoende hoor. Ik ga gewoon verder, tot je er mee ophoud."

In plaats daarvan, valt de notebook dus gewoon uit, of wisselt hij naar de tweede accu.

De sniffer die ik in het vorige artikel liet zien, kon deze data onderscheppen. En het eerste probleem waar ik dan tegenaan loop is dat het Host IC, diegene zonder documentatie, compleet willekeurige variabele opvraagt, in een ogenschijnlijk willekeurige volgorde. En ook nog eens heel traag. Waarom!!!!!?

Als we de data die opgevraagd wordt überhaupt uit kunnen lezen, gaat dat ongetwijfeld lelijke dingen op leveren. Dus we moeten voordat we dingen kunnen meten, de informatie die de accu beschikbaar stelt, er direct uit zien te halen.

Om dit de toen, moet de sniffer iets verbouwd worden.
Verkeer
De datasheet van het IC in mijn accu, een BQ2084, heeft op pagina 14 een mooie tabel met alle dingen die je kunt opvragen. Al die functies komen regelrecht uit de Smart Battery Data specification, en het verbaast me dan ook niet dat ze er in zitten.
Dit betekend, dat andere IC's ook aan deze standaard voldoen....

Een accu uit een EliteBook 8540w, met daarin een BQ20Z70 bijvoorbeeld. Met een klein verloop plugje meld ook hij zich netjes aan:
Hier moet nog een verloopje tussen
Hij doet het, maar is wel stuk...
Deze is er ook al na c.a. 280 cycli mee opgehouden. Wat betekend, dat als je elke dag naar college gaat, je accu het een jaartje vol houd, maar voor die tijd al significant minder gaat presteren.

Nu ik het verkeer tussen de notebook en accu heb kunnen afluisteren, weet ik ook welke adressen gebruikt worden. Die heb ik met groen en blauw(ish) aangegeven. Groen zijn dingen die je verwacht, zoals spanning, stroom, temperatuur en dat soort dingen. Blauw zijn de iets fabrikant specifiekere registers.Gemonitord(t)? verkeer uit een BQ2084Tabel komt uit de BQ2084 Datasheet, en staat ook in de Smart Battery Specification

Ik wil dus gewoon een paar van deze variabelen continu opvragen, en in een grafiekje douwen.
Hoi Accu!
Ja, hier word het weer een klein beetje technisch. De Atmega moet namelijk gaan doen alsof hij een laptop is. Dit is niet heel erg ingewikkeld, want het staat best wel goed wel aardig gedocumenteerd. (Dank u wel TI.)

Hoe er data opgevraagd moet worden, staat onder het kopje "Figure 5. SMBus Communication Protocol Without PEC". Er is ook een kopje "With PEC", maar die verschillen verder niet... ik vermoed een foutje?
PEC is een CRC-8 berekening die aan het eind van een bericht toegevoegd wordt.
De sniffer heeft al vast gesteld dat dat niet gebruikt wordt. De datasheet suggereerd dit:
BQ2084 Read Word
Maar eigenlijk is het dus dit:SMBus Read Word without PEC

Voor dit gebabbel kan de hardware TWI van de Atmega ingezet gaan worden. Het vereiste lapje code kan nu in één interrupt, waar de sniffer voor elke pin een aparte interrupt nodig had:

C: Interrupt.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//Handles SMBus Read Word
ISR(TWI_vect){
    // Save TWI state in an array for debugging.
    smbus_data[chars] = TWDR;
    smbus_reg[chars] = TWSR;
    chars++;
    if (chars == SMBUS_BUFF)
        chars = 0;  
    // State machine:
    if ((TWSR & 0xF8)==0x08){
        //Send adress + R
        TWDR = 0x16;
        TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWIE); 
    }else if ((TWSR & 0xF8)==0x18){
        // Send Command
        TWDR = smb_cmd;
        TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWIE);  
    }else if (((TWSR & 0xF8)==0x28)||((TWSR & 0xF8)==0x30)){
        //Send Repeated Start       
        TWCR = (1<<TWEN) | (1<<TWSTA) | (1<<TWINT) | (1<<TWIE); 
    }else if ((TWSR & 0xF8)==0x10){
        // Repeated start Send, Ack REceived. Send Adress + Write       
        TWDR = 0x17;
        TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWIE); 
    }else if ((TWSR & 0xF8)==0x40){
        // Adres+Write sent, ACK received. Receive Data, return ACK.        
        TWCR = (1<<TWEN) | (1<<TWEA) | (1<<TWINT) | (1<<TWIE); 
    }else if ((TWSR & 0xF8)==0x50){
        // Receive Data, return NACK.
        smb_wrd_lo = TWDR;
        TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWIE);  
    }else if ((TWSR & 0xF8)==0x58){
        // Done. Send Stop condition    
        smb_wrd_hi = TWDR;      
        TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT) | (1<<TWIE);         
        smb_done = 1;
    }else{
        TWCR = 0;   
    }

Ja, hier had een switch statement kunnen staan...

En vervolgens moet ik een functie in het leven roepen die ik het commando als argument mee geef, en die functie geeft mij dan de waarde van het register terug: Dus: sendcommand(Voltage) moet als waarde netjes de spanning terug geven:
C: read_word
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
volatile uint16_t read_smbus_word(uint8_t cmd){
    smb_cmd = cmd;
    smb_done = 0;   
    //Send start condition, enable intterupt.
    TWCR = (1<<TWEN) | (1<<TWSTA) | (1<<TWINT) | (1<<TWIE); 
    // For now, wait until the interrup completes and Stop has been sent.
    // If it takes too long, return.
    for (uint16_t i=0;i<0xFFF0;i++){
        if(smb_done){
            if (!(TWCR & (1<<TWSTO)))
                return ((smb_wrd_hi<<8) | smb_wrd_lo);
        }
    }   
    return 0;       
}

While loops zijn evil. Programma's crashen door overmatig gebruik van while loops. Als er na zoveel i++jes geen antwoord komt, gaat het ook nooit komen, en kunnen we beter ophouden.

En als laatste wordt dus de hele mikmak 25 keer per seconde opgevraagd, netjes geformatteerd en over de USB naar de PC geduwd . Dat levert dan bijvoorbeeld het volgende op:

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
11433 3801 3815 3817    0     0   0
11433 3801 3815 3817    0     0   0
11433 3801 3815 3817    0     0   0
11433 3801 3815 3817    0     0   0
11433 3801 3815 3817    0     0   0
11433 3801 3815 3817    0     0   0
11434 3802 3814 3818    0     0   0
11434 3802 3814 3818    0     0   0
11434 3802 3814 3818    0     0   0
11434 3802 3814 3818    0     0   0
11434 3802 3814 3818    0     0   0
11434 3802 3814 3818    0     0   0
11434 3802 3814 3818    0     0   0

In volgorde: Vtotaal[mV], V3[mV],V2[mV],V1[mV], Current[mA], Capacity[mAh], SOC[%]

En dan kom je al snel tot de conclusie dat het nutteloos is om het 25 keer per seconde op te vragen. Dit chipje update alle waardes maar iets van 1 keer per seconde. Dat noem ik jammer.
Maar, een uur lang iedere seconde een meting, kan nog steeds leuke plaatjes gaan opleveren.

Op de PC hebben we dan een tooltje nodig wat het uitleest en in een bestand prakt, het belangrijkste daarvan ziet er zo uit:

C: Sniff-logger.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void handle_line(uint8_t* line, uint8_t len){   
    sscanf((char*)line,"%u %u %u %u %i %u %u %u",&voltage,&cel3,&cel2,&cel1,&current,&capacity,&soc,&temp);
    system("cls");
    if (dlog)
        printf("Logging...\r\n");
    else
        printf("NOT LOGGING!\r\n");
    printf("Voltage   (mV): %u \r\n",voltage);
    printf("Cell 3    (mV): %u \r\n",cel3);
    printf("Cell 2    (mV): %u \r\n",cel2);
    printf("Cell 1    (mV): %u \r\n",cel1);
    printf("Current   (mA): %i \r\n",current);
    printf("Capacity (mAh): %u \r\n",capacity);
    printf("State O.C. (%%): %u \r\n",soc);
    printf("Temperat. (*C): %2.1f \r\n",(float(temp)-2731.5)/10);
    
    tcurrent = time(NULL);
    tcurrent = tcurrent-tstart;
    printf("Runtime    (s): %u \r\n",tcurrent);

    sprintf(logline,"%u;%u;%u;%u;%u;%i;%u;%u;%u;%u\n",voltage,cel1,cel2,cel3,cel4,current,capacity,soc,temp,tcurrent);
    log_append();
}

Temperatuur wordt in Kelvin uitgepoept en op de PC naar graden C geconverteerd. Verder wordt er een timestamp aan vast geknoopt.

Serial-to-Excel converter v0.000001 pre-AlfaEen positieve current is opladen, negatief is ontladen.

De batterij die ik nu ga testen heb ik van een mede tweaker opgestuurd gekregen. Wat ik ook met deze batterij doe, hij blijft van mening dat er 1mAh in kan. Hij laad wel op, maar omdat hij foutieve informatie aan de notebook doorgeeft, heeft m'n noteboek zoiets van: "Ja, doei! Ik kap er mee. Je zoekt het maar uit!"

Wat we kunnen doen, is het helemaal opladen, en dan helemaal leeg laten lopen door er een halogeen lampje (bij gebrek aan iets beters) aan te hangen.

Dit levert de volgende interessante plotjes op:
Ontladen: Totale Spanning
Ontladen: Stroom

Nou, dit is precies wat je van een accu verwacht, als je je het plaatje herinnert uit de eerste post. En het plaatje hoe het er uit zou zien als je er 2x zoveel stroom uit zo trekken. De stroom is hier niet volledig constant, maar bij benadering wel. Het lijkt er daarom ook sterk op.

Ik heb nu ook voor het eerst iets goeds over deze accu te melden: Hij doet wat hij moet doen, namelijk stroom leveren, en uit gaan als hij te diep ontladen wordt. Dit doet hij op basis van de cel spanningen, en dat laat het volgende grafiekje mooi zien:

http://tweakers.net/ext/f/nQgM5SIfQLbyFT9d0Czp2HT4/full.png

Dit pack is uit balans. Dat wil zeggen dat een van de cellen niet zoveel capaciteit meer heeft als de rest, en daarom eerder leeg is. Idealiter gezien, is het aan de lader om deze te gaan balanceren. Dit kan door of alleen energie in de lege cel te stoppen, of door de twee volle leeg te laten lopen. (Dit laatste is meestal het geval.)

De chip in deze accu kan volgens het datasheet wel balanceren, maar het wordt gewoon niet gedaan. Lekker puh!

Wat verder opvalt is dat een kwartier nadat hij uit is gegaan, de spanning weer stijgt naar een waarde die lijkt te suggereren dat hij weer vol is. Omdat deze cellen toch echt wel een beetje versleten zijn (Ze waren normaal 4800mAh, en nu nog maar iets van 1600mAh).

Dit laatste grafiekje is voor geen mogelijkheid te maken op je PC. Er is geen enkel programma behalve de HP Tool die de individuele cel spanningen tevoorschijn kan toveren.

Verder wordt door mijn notebook alleen de stroom en spanning eens per 2 seconden ofzo opgevraagd. De rest van de dingen die je wilt weten, Idunno... ehm... capacity?, worden op compleet willekeurige tijdstippen met soms wel een minuut of langer er tussen, opgevraagd.

Daarom, als je dit ding aan de notebook hangt, produceert dat stront. Kijk maar eens wat een puinhoop alle Windows tools uitspugen. Er heerst totale anarchie!
Data Bonanza

Windows is van mening dat de batterij (#2) 100% vol is. (It clearly isn't...) Bij BatteryMon past het percentage niet eens in het venstertje... zo veel volheid is er.

Maar de State of Charge in de accu, hoewel niet super lineair, zegt wel netjes in het begin dat hij vol is, en aan het einde dat hij leeg is. Kijk maar:

Ontladen: State of Charge

Het percentage vol wat Windows aangeeft, wordt dus berekend aan de hand van de Remaining Capacity. Dit is in het geval van twee accu's te begrijpen namelijk:

(RemCharge1 + RemCharge2) / (FullCharge1+FullCharge2)*100%

Als het groter dan 100% wordt, maakt ie er netjes 100% van. Want in dit geval wordt het sommetje:

(3189+512)/(3355+1) *100% = 110%.

Na wat meer rond ge-analyseer kom je erachter dat de tijd die nog resterend is, niet berekend wordt als:

(RemainingCarge1 + RemainingCharge2) / AverageCurrent

Wat op zich best logisch zou zijn. Als je uit de eenheid mAh, wat dus stroom*uur is, de stroom weer weg deelt, houd je namelijk een tijd over. De resterende accu tijd.

Nee, in plaats daarvan wordt er naar de (berekende) State of Charge gekeken. En als die veranderd, wordt aan de hand van de afname, en hoe lang het duurde voordat die afname plaatsvond, een voorspelling gedaan.
Gezien de SMBus host hier op compleet willekeurige tijdstippen de Remaining Capacity opvraagd, met soms wel tien minuten ertussen, duurt het moeilijk lang voordat Windows een idee heeft hoelang de accu nog mee gaat, is de voorspelling nogal slecht, en krijgen alle tools die plotjes van de batterij maken van die mooie hoekjes er in:
Poehee, wat een soepel lijntje. Keurig.

Terwijl het met een data-ruiker, ook zo kan:
Opladen: Remaining CapacityGrafiek van de accu die door de lamp was leeg gezogen, weer aan de lader met data-snuiver er tussen.
Ja, leuk. En nu?
Nu... zou ik eigenlijk de dooie accu ervan willen gaan overtuigen dat hij een capaciteit van 1600mAh heeft, gezien de lamp-test zegt dat dat er uit aan totale energie uit komt rollen .

Het probleem is, als je in het gekleurde tabelletje aan het begin weer bekijkt, dat de acces voor RemainingCapacity op read staat. Wij kunnen de waarde dus niet zomaar aanpassen.

Kan het wel minder zomaar? In theorie: Ja.

De documentatie zegt bij het kopje Manufacturer Access(0x00) allemaal oninteressante dingen, behalve deze twee: SHIP Command en Seal command. En de description achter het Seal Command luid:
"Instructs the BQ2084 to restrict access to those functions listed in Table3. It completes the Seal function and clears the Manufacturer Access."

Als ik de Pack Status and Pack Configuration (0x2f) opvraag, staat de SS bit op 1. En dat betekend dat deze accu gesealed is.

Nu kan ik een uur lang gaan vertellen wat er toen gebeurde, maar de SFW-versie komt er in het kort op neer dat ik heel Google dood ge-queried heb met zoektermen als Unseal BQ2084, HP battery key, hp unseal, remove seal... etc etc. Er zijn te veel Aziatische, Poolse, Tsjechse websites voorbij gekomen. Allemaal levert het niks op. (De NSFW-versie bevat veel gevloek en dood ge-wens...)

Uiteindelijk kom je erachter dat er een default key bestaat, die vond ik op het TI forum. Iedereen die op dat forum om de default key vraagt (myself included) krijgt binnen een uur een persoonlijk bericht van een TI medewerker met de key, maar hij wordt niet op het forum geplaatst.... dubieus.

Verder is er geen enkel document van TI dat suggereert waar je die key precies naar weg moet schrijven, en al helemaal niet hoe. Er is alleen een document wat met de Evaluation Software van TI werkt, en die zegt: druk op Unseal, doe de key in box 1, doe de andere key in box 2... en tadaa!

Met veel pijn en moeite ben ik er dus achter gekomen dat de default key (*kuch* 0x2084 en 0x7A43 *kuch*) achter elkaar naar register 0 weg geschreven moeten worden, en dat zou dan de magic moeten doen. Het is me door een TI medewerker bevestigd.

Nou heb ik uiteraard alle combinaties hiervan geprobeerd, maar geen eentje deed iets. Ik heb dus het donkere vermoeden dat HP de code veranderd heeft. (Dat kan namelijk.)

En helaas zou een brute-force scriptje, bij 32 bits met iets van 100 keys/seconde er maximaal anderhalf jaar ofzo over doen.... En eigenlijk weet ik niet zeker of je er wel zo snel zoveel keys naartoe kunt smijten. (Ik heb het een uurtje laten draaien, en hij is niet stukker gegaan...)

Kortom, met een kans op falen van meer dan 0% en een looptijd van meer dan een jaar, heb ik daar niet zo'n zin in. Maar mocht je iemand kennen met een Raspberry-PI, Arduino o.i.d. en een stuk of 100 HP accu's ... ben ik wel te porren.
Samenvattend
It's all useless.

De standaard is op zijn best gezegd okee, maar hoe HP, en Windows hem vervolgens toe past is jammer.
Ik heb plotjes die echt de meest ranzige laad stroom laten zien die je een Li-Ion kunt toe wensen.
Er wordt niet gebalanceerd.
De nuttige beschikbare informatie die de accu bevat, wordt niet uitgelezen, of gewoon genegeerd.
De informatie die beschikbaar is, beland in een half-gedocumenteerde vage Windows API, waar vervolgens elk programma een waarde uit zuigt, door een staafmixer van onsamenhangende formules heen haalt, en in een scherm deponeert, wat dan zegt: "Dit is hoe het ermee staat."

De notebook besluit zelf wanneer de accu leeg is, terwijl de accu dit veel beter weet.
De belangrijkste logica zit achter een muur van NDA's, terwijl de accu zelf ook beveiligd is. Als hij dus (by design) voorbarig stuk gaat, kun je er nauwelijks iets aan doen.
Cellen vervangen heeft maar zoveel zin, gezien het onmogelijk is om de accu fatsoenlijk te kalibreren zonder er halogeen lampen aan te bengelen.

Maar, dat is allemaal mijn mening.

Gelukkig is het niet afgelopen, want ik heb op het gebied van communicatie één ding nog niet gedaan......

Domme Batterijen - Accupologie

Door Infant op woensdag 19 december 2012 22:17 - Reacties (16)
Categorieën: Gemod / Gefix, Notebook: Accu's bouwen!, Views: 7.068

In mijn vorige post heb ik een accu open gepeuterd, en hem aan mijn notebook gehangen.
Tot mijn grote verbazing laad mijn notebook, die normaal alleen met 3-cells accu's om kan gaan, ook doodleuk accu's uit andere modellen notebooks.

Ik heb een 2730p, en de accu's die hij vrolijk oplaad komen uit een nx7400, een 8510W, een 6715b , 6730s.... de lijst telt op het moment zo'n 60 regels.

Ik heb een beetje uitgelegd wat er zoal in zit, en een klein beetje bekeken waarom alle accu's die ik heb, van mening zijn dat ze stuk zijn.

In deze post ga ik wat verder: Ik ga uit leggen hoe ze met de PC communiceren, en ga ik er eentje snuiven.... ?

Hier volgt een waarschuwing: Het wordt een lang verhaal. Er gaat code zijn, maar gelukkig ook plaatjes. De samenvatting niet staat aan het eind, want het hele artikel is al de samenvatting.

Waarom? Omdat accu's geweldige dingen zijn, en ik me er aan stoor dat ze op elke notebook die ik tot nu toe gehad heb (modellen uit 1998 tm nu) ze niet fatsoenlijk werken.
Deze lap tekst is voor mijzelf een stuk documentatie, want ik merk als ik het een weekje laat liggen, ik alle listige dingetjes kwijt raak en vergeet. En wellicht heeft iemand anders er ook wat aan.
Links
Ter referentie, een lijstje datasheets die ik aanhaal in dit artikel:

SMBus v1.1 Specification
Smart Battery Data Specification v1.1
BQ2084 Datasheet
Atmega16U4 Datasheet
Elitebook 2730p Schema (Mediafire)

Die laatste is geloof ik niet helemaal de bedoeling dat we die kunnen zien, gezien er groot CONFIDENTIAL op staat... maar ach... het helpt wel enorm.
Overzicht
Hoe het, een notebook, in zijn geheel werkt... is te veel om uit te leggen. Als je alles in grote blokken opdeelt, wordt het steeds beter te behappen:

Hieronder heb ik een schema getekend hoe het vermogen in mijn notebook ongeveer loopt:

Schema Elitebook

Het bestaat uit vier hoofd delen (grijs omringd):
  • De notebook
  • De adapter
  • 2 batterijen
Alles wat energie verbruikt, wordt gevoed door een grote bak DC/DC converters, en die heb ik allemaal in het blok rechtsonder weg gewerkt.

Naar dat blok gaan twee rode lijnen, met twee schakelaars.

De rode lijn stelt de plus van een voedings spanning voor, en de schakelaar zijn in dit geval meestal twee stuks PFETs met de drains aan elkaar geknoopt.
Maar, in essentie worden ze gebruikt als aan/uit schakelaar. Vandaar dat ik ze zo in het schema heb gezet.

Als ik de 19V adapter in mijn notebook prik, duurt het even voordat het power lampje aan gaat. Dit is omdat hij dit schakelaartje dus eerst op 'aan' moet zetten. (Er zit een RC op de gate)

Links daarvan zit de lader. Zijn enige doel in het leven is de batterij in mijn notebook opladen. Die kan dus ook aan en uit worden gezet met een schakelaar.

Omdat de lader maar één batterij tegelijk kan opladen....
Er is voor gekozen om de lader maar één batterij tegelijk op te laten laden.

Hiervoor is er een 'battery selector' in het leven geroepen. Deze knoopt een van de twee batterijen aan de lader vast.

Als we niet aan het laden zijn, maar vanaf de batterij werken kiest de battery selector een batterij uit, en knoopt hij die via het aan/uit knopje aan de DC/DC converter... en alles in de notebook krijgt prik.

Verder valt het op dat er in de batterij ook een aan/uit schakelaar zit. De batterij kan zichzelf namelijk ook uit zetten, als hij denkt dat dat nodig is.
Accupologie
Iemand die zich bezig houd met het gedrag van accu's. (Of met hun polen...?)

Er worden twee type's accu bij deze notebook verkocht, en die noemt HP de hoofd batterij, en de reis batterij.
Laatst genoemde klik je onder de notebook, en de naam suggereert dat je daarna op reis gaat.

Als je beide batterijen aan de notebook hangt, wordt de reis batterij als eerste leeg gezogen. Als die 0% aangeeft, wordt de interne batterij leeg gezogen.

Als ik twee batterijen in mijn notebook heb, die beide half vol zijn, en ik prik de lader er in... wordt de reis batterij als eerste opgeladen. En dat vind ik vreemd gedrag. Ik wil de interne batterij als eerst opgeladen hebben. Die gebruik ik het meest.

Ten tweede kwam ik er dus achter, dat ik ook prima een batterij van een andere notebook eraan kan hangen, en die wordt dan gewoon opgeladen en ontladen. Vreemd? Nee.

DO NOT TRY THIS AT HOME! (Unless you know what you're doing.)

Als ik alleen de hoofd accu installeer, en een 12V accu op de pinnen van de externe batterij connector zet en het battery-detect pinnetje aan de min vast maak, ontlaad de hoofd batterij, en als die op is... valt de notebook niet uit?

Er wordt nu stroom uit de externe connector getrokken terwijl het lijkt alsof er geen accu aan hangt. ....MADNESS!

Accu's op, stroom weg...

Begin je je al af te vragen waarom je een 12V naar 19V car adapter gekocht hebt voor het luttele bedrag van 100 ballen? Mooi. Leest u verder.
SMBus
De wiki zegt er verrassend weinig boeiends over, en dat is waarschijnlijk omdat het dat ook niet is.

Kort samengevat is de SMBus specificatie een definitie hoe data over een bus uitgewisseld moet worden. Als je daar vervolgens de Smart Battery Data Specification naast legt, wordt het duidelijk dat er een standaard bestaat die, wanneer je een willekeurige lader aan een willekeurige accu vast maakt, deze twee met elkaar laat praten en uitvogelen wat er moet gebeuren. (Ultimately: De accu opladen.)

Dit willen we weten, omdat je in het schema twee SMBussen ziet zitten, die gaan ieder naar een accu, en doen ogenschijnlijk iets belangrijks.

De SMBus specificatie stelt eigenlijk alleen eisen aan hoe de communicatie er fysiek uit moet zien, d.w.z het aantal lijnen gebruikt om over te communiceren. De voltages die gebruikt worden, alle staten waarin de bus zich kan bevinden en het protocol om data uit te wisselen.

En dit komt in grote lijnen overeen met het I2C protocol.

Er zijn bergen met software die 'iets' met SMBus-sen kunnen:

HWMonitor is een vrij bekend stukje software, die heeft een mooie "Save SMBus data"-knop. Die slaat vervolgens wat meuk op, en die meuk heeft totaal niks met een van m'n twee batterijen te maken.
Zowiezo klopt er geen reedt van dit programma: hij denk namelijk dat er maar één batterij aan hangt. De minimum waarden zijn van de batterij met de laagste waarden, en maximum van degene met de hoogste waarden. Dit gooit ie door elkaar in een tabel en tadaa, alsjeblieft! Zo is het!

Verder geeft hij temperatuur aan die meer dan voldoende zou moeten zijn om stabiel kernfusie op gang te helpen, en gezien ik nog geen paddestoel wolk gezien heb, twijfel ik daar ook wat aan.

Speedfan vind een hele lijst met Adressen op de SMBus, waaronder een Accelerometer en een Fancontroller, maar de rest kan hij niet van vertellen wat het is.
Dit klopt verder allemaal, het schema zegt ook dat deze dingen er zijn, en dat ze inderdaad aan de SMBus van de ICH9M zitten.

Het probleem is dat de batterij daar niet aan zit, maar die zitten ieder op een aparte bus vast aan een IC genaamd KBC1091-NU van SMSC. (Pagina 32 v.h. 2730p cchema) En laat daar nou eens helemaal geen datasheet van bestaan. Grrrr.

Ik heb zelfs de fabrikant gemailt, zonder verder al te hoge verwachtingen op een respons. Toch kwam die, en kijk eens wat ze zeggen:

Hi,
Data supporting this device is only shared via NDA with approved customers.
Greetings.


En approved customers moeten om te beginnen er eerst 100.000 afnemen. 100.000!

BatteryMon is een van de vele tools die net iets meer informatie over je accu kunnen weergeven. Maar deze haalt hij niet direct uit de SMBus, maar wordt uit een Windows API gezogen. En dat is vervelend, want alle software geeft de accu informatie fout weer.

Het is hoog tijd om eens een hartig woordje met de accu te gaan houden, en uit te vinden wat hij allemaal voor een onzin aan mijn notebook verteld. Daarvoor moeten wij gaan:
Bus Snuiven
Als we niet op een makkelijke manier via software met de batterij kunnen babbelen, wil ik wel eens zien wat de batterij überhaupt allemaal te vertellen heeft als hij aan de pc hangt.

De BQ2084 datasheet is vrij uitgebreid, en geeft eigenlijk al genoeg informatie om mee aan de gang te kunnen: (Pagina 20)

"The processor then sends the bq2084-V143 device address of 0001011 (bits 7-1) plus a R/W bit (bit 0) followed by an SMBus command code. The R/W bit (LSB) and the command code instruct the bq2084-V143 to either store the forthcoming data to a register specified by the SMBus command code or output the data from the specified register."

Kortom: 00010110 = 0x16 is het commando om een register te lezen, 0x17 om te schrijven.

"In some instances, the bq2084-V143 acts as the bus master. This occurs when the bq2084-V143 broadcasts charging requirements and alarm conditions to device addresses 0x12 (SBS Smart Charger) and 0x10 (SBS Host Controller.)"

Okee. Dus alles heeft een vast adres?

Op pagina 39 van de SMBus specificatie staat inderdaad een 7-bit adres: Smart Battery: 0001 011

Dat betekend dus, als je twee batterijen hebt, zoals deze notebook, heb je twee bussen nodig om er mee te kunnen praten. Er kan namelijk maar een adres per bus hetzelfde zijn. Dit verklaart waarom er ook twee bussen naar het SMSC IC gaan. Maar waarom gaan we dan een bus gebruiken als we er maar een ding aan kunnen hangen? Whatever.

In hetzelfde document staan de signalen nogmaals beschreven, en die komen overeen met de TWI signalen zoals die in een Atmel Atmel datasheet staat. En gezien er daar eentje van voor mijn neus ligt, vraagt hij er om, om ingezet te worden als snuiver.
TWI op een Atmel
De Atmega die ik toevallig nog had liggen, een Atmega16U4, heeft net als vele andere een Hardware TWI interface. TWI staat voor two-wire interface, en die is ook eigenlijk weer hetzelfde als een I2C interface en die op zijn beurt weer hetzelfde als de SMBus interface is. Semantics.

Belangrijk nu is dat alle data wordt voorafgegaan aan een START signaal, daarna vind er communicatie plaats, en vervolgens een STOP signaal.

We gaan dus een bus-snuiver maken. (Ik houd van Engels letterlijk vertalen.) Dan kunnen we namelijk al het verkeer tussen de PC en batterij afluisteren, zonder in Linux kernels te moeten gaan rond wroeten, god forbid, een Windows driver schrijven of op dubieuze websites naar niet bestaande datasheets graven.

Ruik en Snuiver

En ik weet nu dat er op de bus in ieder geval een batterij gaat zitten, en die gaat data ontvangen en terug schreeuwen naar op z'n minst een lader.

Het vervelende aan de TWI interface is dat om data te kunnen ontvangen, je bij deze Atmega een vast adres moet opgeven. En ik wil eigenlijk gewoon alles zien.

Om het dit te doen, en om het hele communicatie proces verder zo min mogelijk in de weg te zitten, gebruik ik niet de TWI interface, maar pak ik het anders aan:

De SDA en de SCL (Data resp. Clock) hangen we beiden aan een interrupt, de Atmega16U4 heeft er een paar, ik ga INT0 en INT1 gebruiken.

Elke keer als een van deze pinnen van 0 naar 1, of van 1 naar 0 gaat, wordt de Interrupt aangeroepen. Met de beschrijving van de signalen kunnen we dan zelf de START en STOP condities eruit vissen, en alles daartussen was data. (Er is ook nog zoiets als een REPEATED START, maar die is exact hetzelfde als gewoon START).

Er draait verder op de Atmel een USB driver op die zich als seriële poort aanmeld (wat onder Windows vet klote is, maar het werkt) waar we alle dingen die we willen weten over naar buiten gaan poepen.

Omdat de micro ook nog USB interrupts moet afhandelen, wordt het tricky. Gelukkig hoeft dit niet al te snel, maar moet zo uit mijn hoofd wel binnen iets van 100ms gebeuren.

Dus, we gaan eerst gewoon steeds 50ms kijken of de interrupt pinnen heen en weer gewiebeld worden, en hoe vaak. Daarvoor zet je gewoon de interrupts aan, en wacht je een tijdje.
C: Main.c
1
2
3
4
5
6
7
sei();
sda_change = 0;
scl_change = 0;
_delay_ms(50);
cli();
...
msglen = sprintf(msgbuff,"%3u %3u",sda_change,scl_change);


C: Interrupts
1
2
3
4
5
6
7
ISR(INT0_vect) {
    scl_change++;
}

ISR(INT1_vect) {
    sda_change++;   
}


Dat was de meest kort interrupt code ooit. Bij elke wisseling wordt er gewoon 1 bij een getal opgeteld, en dat wordt vervolgens in een buffertje geprint. Verderop wordt die door een stukje USB code naar de PC geduwd. Hoe dat verder allemaal werkt is niet zo belangrijk, wat belangrijk is, is dat er geteld wordt, en de output dit geeft:

code: Interrupt Output
1
2
3
4
5
6
7
52 188 
 0  0  
 0  0
 0  0  
 22  94 
 0  0
 0  0


In werkelijkheid zaten er nog veel meer 0-en tussen. Er gebeurt dus voornamelijk niks, maar af en toe komt er wat gewiebel voorbij.

Het enige wat er verder hoeft te gebeuren, is de START en STOP condities herkennen. Alles daartussen is data, en dat willen we zien.

C: Interrupts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// SCL Interrupt State Change
ISR(INT0_vect) {
    // Read value of SCL into scl
    bitSCL = PIND & SCL;        
    if (bitSCL){ //On positive going edge.
        if (bit_cnt>0){
            if (bitSDA)
                byte_val |= (1<<(bit_cnt-1));           
        }else{
            bit_cnt = 9;
            if (chars >= SMBUS_BUFF)
                chars = 0;          
            smbus_data[chars] = byte_val;
            byte_val = 0;
            chars++;
        }
        bit_cnt--;
    }   
    scl_change++;
    return;
}

// SDA Interrupt State Change
ISR(INT1_vect) {
    // Readit!
    bitSDA = PIND & SDA;    
    if (bitSDA && bitSCL){
        cond = COND_STOP;   
        stop_cnt++;
        bit_cnt = 8;
        byte_val = 0;       
    }else if (bitSCL){
        cond = COND_START;
        bit_cnt = 8;
        byte_val = 0;       
        start_cnt++;
    }else{
        cond = COND_DATA;
    }
    sda_change++;   
    return;
}


Dit is eigenlijk een vrij kort stukje code geworden. Het moet ook zo kort mogelijk zijn, want als het te lang duurt, zijn we niet klaar voordat de volgende interrupt afgaat, en missen we stukjes data.

De smbus_data array bevat nu een aantal characters. Verder wordt het aantal SDA changes, het aantal SCL changes, aantal START, aantal STOP condities geteld. En die gooit ie vererop naar de PC toe. Alle regels waar niks op gebeurt heb ik er tussenuit gevist:
En dat geeft:

code: Beeld
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
52 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 52 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 22  94   2   1 16  B 17  0  0 
 51 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 52 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 24  94   2   1 16  A 17  0  0 
 53 188   4   2 16  9 17 8D 40 16  A 17  0  0 
 55 188   4   2 16  9 17 8D 40 16  A 17  0  0 
 27  94   2   1 16 10 17 46  6 
 50 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 28  94   2   1 16  D 17 4B  0 
 52 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 53 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 31  94   2   1 16  8 17 96  B 
 51 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 53 188   4   2 16  9 17 8D 40 16  A 17  0  0 
 22  94   2   1 16  B 17  0  0 
 52 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 50 188   4   2 16  9 17 8C 40 16  A 17  0  0 
 24  94   2   1 16  A 17  0  0 
 52 188   4   2 16  9 17 8C 40 16  A 17  0  0



Op de eerste regel, is het eerste getal het aantal SDA changes, de volgende SCL changes, dan het aantal START condities, en het aantal STOP condities. De rest is data.

Dit is dus wat er in de huidige toestand zo'n beetje voorbij komt vliegen, en begint al goed ergens op te lijken. Ter vergelijking wordt de HP Tool weer tot leven geroepen:
Okee, en nu?

De tweede batterij is degene die ik aan het afluisteren ben, en die heeft bijvoorbeeld als status code C0. De BQ2084 datasheet geeft bij BatteryStatus() (0x16) een lijstje met bitwaardes en hun beschrijving. (Pagina 43).
De regel die we opgevangen hebben die daar bij hoort:

code: Status code regel
1
16 16 17 C0  0



Het eerste getal, was het batterij adres met de R/W bit op 0. De lader vraagt dus een register uit de batterij op. Het tweede getal is het commando, weer 0x16. Hij vraagt dus de BatteryStatus op.
0x17 is weer zijn eigen adres, met de R/W bit op 1 (Bij elkaar dus 0x17).
En de twee bytes antwoord C0 en 00 zouden vertalen naar de volgende twee statussen:

0x0080 - Initialised
0x0040 - DISCHARGING

Voor de hoofd batterij zal dat dus betekenen:

0x4000 - TERMINATE_CHARGE_ALARM
0x0080 - Initialised
0x0040 - DISCHARGING
0x0020 - FULLY_CHARGED

De hoofd batterij heeft een alarm afgegeven aan de lader, om te nokken met laden. En verder zegt ie: Ik ben volledig opgeladen!

Maar lieve batterij. Ik weet dat je niet vol bent. Waarom laad je niet op? Doorladen kreng!

De tweede batterij is om onduidelijk reden ook gewoon lekker niet aan het opladen.

On another side note, begrijp ik nu waarom de HP Tool er zo onnozel lang over doet om de batterij informatie op te vragen. Als je op de refresh knop drukt, gebeurt er namelijk niks in het dataverkeer. Kennelijk verzameld hij dus gewoon alle informatie die maar wat willekeurig voorbij komt vliegen.

Verder valt op, dat wat er nogal vaak voorbij komt het volgende is:

code: Status code regel
1
16  9 17 8C 40 16  A 17  0  0



0x16 is weer naar de batterij toe, en 0x17 is nog steeds het antwoord terug.

Tabel 3 op pagina 14 geeft de hele lijst met commandos die naar de BQ2084 geschoten kunnen worden, en verderop wordt per commando uitgelegd hoe de data geïnterpreteerd moet worden.

Hier wordt achter elkaar command 0x09 en 0x0A verstuurd. Voltage en Current

Het antwoord is in Little-Endian en leest in Big-Endian dus resp. 0x408C en 0x0000.

0x408C is in decimale getallen 16524, en laat dat nou exact het getal zijn wat bij Terminal Voltage in de HP Tool staat. En de current is inderdaad 0 mA.

Woepie, het is altijd fijn als dingen blijken te kloppen. Ik kan dus nu fijn al het verkeer tussen de batterij en de lader volgen en analyseren.
Ennu?
Nu is het artikel afgelopen... want het wordt te lang. Gelukkig volgt er meer, veel meer.

Het schema wat ik aan het begin geplakt heb, gaat voor een heleboel fabrikanten op. Iedereen bouwt maar wat aan, gebaseerd op een losjes gedefinieerde standaard. Bij elke nieuwe notebook mag je als consument een nieuwe accu kopen, een nieuwe lader met een ander stekkertje. Plugje hier, plastic-je daar... en bam. Weer een maand eten verder.

Elektrisch gezien is het allemaal niet nodig, maar marketing technisch....

Domme Batterijen

Door Infant op vrijdag 14 december 2012 23:09 - Reacties (22)
Categorieën: Gemod / Gefix, Notebook: Accu's bouwen!, Views: 13.774

Dit artikel, waar er nog een paar op gaan volgen, zal gaan over batterijen.

Je kunt de eerste 1:30 van dit nummer luisteren, om goed te laten bezinken waar het over zal gaan.

Ben je het nu al zat? Dan zou ik niet verder lezen want het gaat lang duren!

Ik ga het specifiek over laptop batterijen hebben, en dan nog specifieker over degene waar ik wat aan heb, namelijk voor in een HP Elitebook 2730p, maar het gaat in grote lijnen ook gelden voor andere notebooks.
Inleiding
Vandaag de dag ga je in je notebook en Lithium-Ion of Lythium-Polymeer accu aantreffen. Het verschil tussen de twee is de chemische opbouw en meestal tref je li-ion in ronde cellen aan, en li-po in platte cellen.

Maar, dit is niet interessant. Wat interessant is, is hoe ze zich gedragen.

Beide varianten exploderen graag. Boem!
Meestal als je ze te vol met energie stopt, ze te warm worden, je er een gat erin boort of kort-sluit.

Om te zorgen dat ze niet exploderen, is bijna elke batterij waar li-ion cellen in zitten, voorzien van een stuk elektronica die constant in de gaten houd of ze niet te heet worden en niet te vol of leeg raken.

Elke fabrikant heeft wel eens een hele serie batterijen terug moeten halen, Dell, HP, Apple, Nokia. Allemaal omdat er een vergrote kans op BOEM aanwezig was.

Dat elke fabrikant er last van heeft, is niet heel gek, gezien ze allemaal een soortgelijke opbouw gebruiken voor hun batterijen.

In het kort bestaat een batterij, of accupack in je notebook uit de volgende onderdelen:

- Een aantal lithium cellen.
- Een of meerdere temperatuur sensoren
- Een zekering
- Een circuit die de cellen in de gaten houd, en alles aanstuurt.

Ik merk dat zelfs op de universiteit, het basis begrip stroom en spanning totaal niet ingeburgerd is bij de niet EE-ers, dus hieronder een korte uitleg, zodat de rest van het geblaat een beetje te volgen gaat zijn.
Een klein beetje terminologie:
Goed. Een notebook, laptop of elk ander apparaat, heeft in de volksmond stroom nodig. Dit is deels waar:

Elk apparaat heeft namelijk energie nodig. Energie kan een boel dingen betekenen, maar in elektronica betekent het:

E = P * t

E = Energie [Joules]
P = Vermogen [Watt]
t = tijd [Seconden]

Tijd is, zonder daar verder iets mee te doen, makkelijk te begrijpen. Wat rest is dus vermogen. Wat is dat?

Vermogen is:

P = U * I

P = Vermogen [Watt]
U = Spanning [Volt]
I = Stroom [A]

Dus energie is Tijd * Spanning * Stroom. Simpel, toch?

Als je dus wilt weten hoe lang je laptop het gaat volhouden op de accu (tijd), moet je weten hoeveel energie er in de accu zit, en hoeveel energie de laptop gebruikt.

Hoeveel energie je laptop gebruikt is volledig afhankelijk van wat je aan het doen bent, en is dus ook totaal niet constant. Als het scherm uit staat en hij verveelt zich, gebruikt het ding misschien 6 Watt. Als je aan het gamen bent misschien 25 Watt.

De hoeveelheid energie in een batterij, staat er meestal op geschreven, en staan bijv. zo genoteerd:

44 Wh = 44 Watt * Uur [Joules]
4000 mAh = 4000 milli Ampere * Uur [Coulomb]
4.0 Ah = 4.0 Ampere * Uur [Coulomb]

En betekend grofweg dat het ding een uur lang, continue 44 Watt kan leveren.
Of, een uur lang 4 Ampere kan leveren.

What's the bloody difference?

Het verschil ligt er aan, hoe je er naar kijkt.

Een batterij, heeft afhankelijk van zijn chemie, een spanning tussen de + en - pool staan. Een AA of AAA alkaline batterij 1.5V, en een Ni-Mh 1.2V.

Op een litium cel, bijv. die in je telefoon staat 3.7V geschreven. In een notebook zitten er meestal meerdere, om een hogere spanning te maken van 11.1 of 14.4 Volt.

Stel wij nemen een 100% opgeladen lithium cel van 1 Ah, en laten die een uur lang 1A leveren aan... een ding. Geplot, ziet dat er zo uit... ongeveer:
Spanning bij constante stroom

De spanning begint bij 4.2 Volt, en zakt vrij snel af, blijft een tijdje constant, en zakt dan verder af.

Na een uur is hij leeg.

Omdat de stroom gedurende de 60 minuten constant was, ziet de stroom * spanning er exact hetzelfde uit:
Het vermogen op tijdstip 0 is dus 4.2 Watt, en op tijdstip 60 nog maar 2.7 Watt. De stroom was wel constant.

Omdat de totale energie gelijk is aan vermogen * tijd, kun je een grove benadering doen en zeggen dat de spanning gemiddeld genomen vlak was. Het oppervlak onder de grafiek wordt dan je totale energie:
Energie bij constante stroom

Dat is hier dus het groene vlak. De rode lijn komt ongeveer evenveel boven als beneden de vlakke lijn, dus gemiddeld genomen was het vermogen steeds 3.7 Watt.

De totale energie kan dus prima in Ampere * uur uitgedrukt worden, of in Watt * uur. De laatste is eigenlijk nauwkeuriger en beter.

Als we dus een 40 Wh batterij nemen, en 20 Watt er uit trekken, kunnen we aardig voorspellen hoe lang het ding nog meer gaat.. ongeveeer 2 uur.

Maar... als wij nou in plaats van 1 Ampere, 2 Ampere uit de cel trekken, wat dan? Nou, dan gebeurt er bijvoorbeeld dit:
Energie bij 2x stroom

Nu wordt het al wat lastiger....

De vorm en lengte van de curve is afhankelijk van de hoeveelheid stroom die we vragen. Niet alleen wordt de lijn moeilijker te voorspellen als we een wisselende stroom vragen, de temperatuur heeft ook een gigantische invloed op de prestaties.
De capaciteit en interne weerstand neemt af naarmate de cel ouder wordt, en is afhankelijk van hoe vaak hij gebruikt is.

Wij vinden het als eindgebruiker van een laptop, bijzonder interessant om te weten hoe lang onze batterij nog mee gaat. Ik wel in ieder geval. Daarom moet er een zo nauwkeurig mogelijke voorspelling gedaan worden over hoeveel energie er nog uit een batterij kan komen fietsen.

Vandaar, de ontwikkeling genaamd het batterij icoontje.

Ieder OS heeft er eentje. In Windows 95 t/m 7 zit die rechts onderin verstopt. Ubuntu heeft hem rechts bovenin geprakt, net als OSX.

Wat al deze OS-en doen, is eigenlijk hetzelfde, namelijk: Ze vragen aan de batterij hoeveel energie er in kan, en hoeveel energie er in zit.
Als de batterij zegt dat er 40 Wh in kan, en 20 Wh in zit... weet het OS dat de batterij nog 50% vol is.

Vervolgens vraagt het OS hoeveel energie er op het moment uit loopt, bijv. 20 Watt.

Dan weet je dat het nog een uur duurt voordat de batterij leeg is. En dat zet je er dan bij. Klaar. Iedereen blij. Klaar. Einde blog.

Nee.

Hoe weet zo'n batterij hoeveel energie er in zit? Was dat niet intens ingewikkeld?

Wat de batterij in essentie doet, is het volgende:

Hij meet elke seconde het vermogen, in Watt, wat de batterij uit loopt. Dit doet hij door de spanning te meten, en de stroom.

Al die metingen telt hij bij elkaar op, totdat de cel zijn laagste spanning heeft bereikt. Als de cel onder deze spanning komt, begint er een ander, on-omkeerbaar chemisch proces. Dit wil je niet, want daar gaat de batterij stuk van.
Dus, het moment dat hij in de buurt komt van deze spanning, schakelt de batterij uit en kapt je laptop met werken.

Nu heeft de batterij een hele rits met vermogens, elke seconde anders. Die tel je allemaal bij elkaar op, en tadaa! Zoveel energie zat er in de batterij, en zoveel kan er dus ook weer in.

En daar gaat het mis.

Laten we kijken wat onze volle HP batterij vandaag van zichzelf vind:

Stuk

Vol, en stuk.

Waarom issie stuk? Je zou het aan HP willen vragen. DOE HET NIET!

De website van HP is weer veranderd, ik denk voor de 3e keer in twee jaar. En, het is er niet veel beter op geworden. De site is on-navigeerbaar.

Om hier geen urenlange HP rant van te maken, hoeveel het ook kriebelt, ga ik verklappen dat er een stuk software bestaat genaamd HP Battery Check. Niemand weet wat de laatste versie is, of hoe je het zou moeten vinden, maar suffice it to say, ik heb een werkende versie, en die gaat ons hopelijk vertellen waarom dit exemplaar stuk is.

Dit programma klik je aan, en toont vervolgens onnodig lang een geanimeerd vergrootglas. Om uiteindelijk iets meer informatie te geven dan dat je al wist: Your battery needs calibrating. Wauw.

Dit betekend dat de batterij de kluts kwijt is. Hij weet niet meer hoeveel energie er in zit, en hier moet hij opnieuw achter komen. Wat je idealiter dan doet is:

Je laad hem helemaal op, in dit geval is het een 3-cells pack, dus die is helemaal vol als de cellen 12.6V meten.

En, vervolgens laat je ze helemaal leeg lopen, tot in dit geval iets van 9 Volt.

Stiekem is dit ook wat HP, en eigenlijk alle fabrikanten voor hun batterij voorstellen. Behalve Lenovo.
Lenovo is cool.
Bij Lenovo zit er een "reset" knopje op, zodat je als klant niet een halve dag aan het kloten bent.

Bij het kalibreren, kan de batterij alle Wattsecondes die er uit lopen bij elkaar optellen, en weet hij weer waar hij aan toe is.

In batterycheck, laat de "Advanced View" zo'n beetje alle informatie zien die je uit de batterij gaat kunnen krijgen:
1mAh

Hier staat design capacity genoemd. Dit is hetzelfde als ook op de batterij staat, namelijk 4800 mAh, en is de fabrieksopgave. Zo veel moet er in kunnen.
Full charge capacity is wat de batterij zelf denkt dat er in kan.
En ten slotte remaining capacity is hoeveel energie er nog in zit.

1 mAh is niet erg veel nee. Als ik de stekker er uit haal, om te kijken wat er gebeurt, en een tijdje wacht, wordt het nog veel mooier:

Veel!

65 Ah! Zoveel zit er niet eens in m'n auto! En die weegt 730 kilo!

Wat nu verder opvalt is dat er 4 cel spanningen staan, terwijl er hier maar drie in zitten. Waarom is dat?

Laten we eens een 4 cell accu open slopen, en kijken wat er zoal in zit:
De Binnenkant
Guts 4-Cell
Foto 1 - De ene kant

Guts 4-Cell - Andere kant 2
Foto 2a: De andere kant

Guts 4-Cell - Andere kant 2
Foto 2a: De andere kant, van de andere kant.

Op de eerste afbeelding zie je een klein IC-tje, een dikke weerstand, en een groot IC. Het gele ding gelabeld RT1 is een thermistor. Hiermee wordt de temperatuur van de cellen gemeten.

Op de tweede foto staan twee mosfets, met een zekering ertussen gefrommeld. En op afbeelding 2a staat weer een IC.

De twee ICs zijn gelabeld BQ2084DBT en BQ23912PW. Komen bij TI vandaan, en ze zijn zo vriendelijk geweest om datasheets te leveren.

Mooi.

En uit de datasheet van de BQ23912 blijkt meteen dat ze bij elkaar horen, en geven ze op pagina 1 meteen aan hoe het zaakje er uit moet zien:

Diagram BQ29312

De sense resistor onderin, hebben we gezien. Evenals de twee mosfets. En er zit ook een klein mosfetje op, om de accu langzaam op te laden als hij helemaal zo dood als een pier is.

Het ontwerp lijkt niet af te wijken van de referentie in de datasheet. Dat doet het meestal nooit.

Helemaal onderin de BQ2084 staat een nog verder uitgewerkt schema, met eigenlijk alle componenten en hun waardes er al in. U1 is daar gelabeld BQ29400 en jawel... het kleine ICtje op het PCB is een BQ29400.

Zijn doel in het leven is de cel spanning in de gaten houden. Als die te hoog wordt, vlamt hij de zekering er uit.

Wat de hele schakeling nodig heeft, is een lader. Al deze ICtjes bij elkaar kunnen namelijk niet laden, maar alleen dingen in de gaten houden en uit zetten al het ongelooflijk mis gaat.

Omdat ik geen zin had om m'n notebook open te breken, heb ik na veel zoeken op een duister forum een circuit diagram van de notebook gevonden:

2730p Schema

En die vertelt ons, onder andere, dat de lader in deze notebook een BQ24740 is.

Het leuke aan al deze ICs is dat ze een ingangs spanning vanaf rond de 7 volt accepteren, en helemaal tot 28 Volt gaan.
De adapter die bij de notebook hoort is 19 Volt, en de twee accu's die er aan kunnen zijn beide maar 11.1 Volt.
Alle DC/DC converters in de notebook moeten uiteraard ook in iedergeval met 19V overweg kunnen, en dus ook met spanningen net boven de 9 Volt.

Het kan dus in ieder geval electrisch gezien geen kwaad om er een 4-cells accu aan te hangen, van 14.4 Volt, en te kijken wat er gebeurt.

Toevallig had ik een 14.4V batterij uit een andere HP liggen, met een verdacht dezelfde aansluiting.

Nameten leverde in ieder geval dat de plus en min op dezelfde pinnen zaten, dus er kan weinig fout gaan. Iets wat Thinkpad ook al eens gedaan heeft, doe ik ook: Een verloop kabeltje gemaakt van UTP, zodat de batterij niet in de notebook hoeft te passen.

Laad Bende

UTP

En jawel, niet alleen wordt de batterij door dit stugge stuk software herkend, hij laad ook vrolijk op! Ondanks het feit dat deze machine helemaal geen 14.4V batterij kan hebben, laad hij ze toch op.

14V!

Dat zou betekenen, dat ik een willekeurige HP accu aan m'n notebook kan hangen, en dat dan alles goed gaat.

En dat is zo, was het niet dat willekeurige HP accu's ook op willekeurige tijdstippen dood gaan. Deze komt uit een HP Compaq 8710w, en die worden op de TU massaal weg gegooid. Niet omdat de cellen stuk zijn. Die zijn namelijk nog prima. Dit specifieke exemplaar heeft nog maar 49 ontlaad cycli mee gemaakt. Dat is nagenoeg nieuw!

Zoals je kunt zien, kappen ze er mee omdat het IC-tje gewoon niet werkt zoals het zou moeten. Ik zou bijna zeggen dat er een fout in zit, want het gedrag wat ik eerder waarnam, waar de capaciteit ineens van 1 mAh naar 65000mAh versprong.... dat lijkt verdacht veel op een overflow.

Gelukkig levert HP maar één jaar garantie op zijn accu's, vanaf productie datum! Dus niet alleen kun je ervan verzekerd zijn dat je accu er op een willekeurig tijdstip mee ophoud, hij valt dan hoogst waarschijnlijk ook nog eens buiten de garantie.

Dit, tezamen met het feit dat elk model een aparte accu heeft, terwijl er elektrisch gezien niks mis mee is om ze uit te wisselen, is uiteraard een prachtig business model. Ik denk dat er heel wat mannen in nette pakjes aan een grote tafel met de marketing en engineering afdeling zitten te bulderen van het lachen terwijl ze naar de kwartaal cijfers kijken.
Mhoehaahhaha PROFIT!!

Wij als niks wetende consument drukken braaf op het toevallig aanwezige linkje "Buy your new battery by clicking this link." Die ons naar de HP webstore door dirigeert, waar je je vervolgens een uur kunt ergeren aan de on-navigeerbaarheid en het feit dat alle accu's gigantisch overpriced zijn.

Damn it, mijn excuses. Er is toch een rant gekomen.
Tot Slot
Mijn doel is nu om een batterij te maken die makkelijk aan mijn notebook kan, herkent wordt en in Windows netjes de voorspelling doet hoe lang hij mee gaat. Gezien geen enkele HP accu eigenlijk out of the box aan deze voorwaarde voldoet, vallen ze allemaal af.

Het probleem bij de paar accu's die ik getest heb, is dat ze niet willen kalibreren. De datasheet van de BQ2084 zegt bij FullChargeCapacity:

"FCC cannot be reduced by more than 256 mAh or increased by more than 512 mAh during any single update cycle."

Wat betekend dat als zo'n ding eenmaal de kluts kwijt is, hij niet zomaar meer tot 4000 mAh gekalibreerd kan worden. Je kunt dus bij oude accu's de cellen wel vervangen, maar daar alleen schiet je niet zo veel mee op.

Ik ben dus bezig om deze dingen iets minder stupid te maken. Mocht iemand een accu voor een 27xxp hebben liggen die van mening is dat ie dood is. Mij help je er mee, want ik heb meer vergelijkings materiaal nodig. Ik heb op V&A al een advertentie staan, en daar heb ik twee exemplaren van andere HP notebooks aan overgehouden, die beide herkend worden, maar ook volledig de kluts kwijt zijn.

Het volgende blog zal gaan over hoe de batterij met de pc praat en zal waarschijnlijk nog wat meer rants over HP brakheid bevatten.

Investering

Door Infant op donderdag 6 december 2012 16:50 - Reacties (21)
Categorie: 4e klas Wiskunde / CBS, Views: 4.362

"Any money on a savings account is just money poorly invested."

En dat is zo. Het variabele rentetarief ligt op het moment rond de 2%, en de inflatie rond de 3%. Dus elk bedrag wat op je bank rekening staat, kost geld.

Je kunt nu meerdere dingen doen met dit "probleem":

1: Het negeren.
2: Alles uitgeven.
3: Investeren.

Op het moment ben ik 1 aan het doen, en dat bevalt me prima.
Aanpak 2 lijkt me geweldig, maar heb ik op het moment niet zo'n behoefte aan.

Stap 3 ga ik nu wat over vertellen.

Investeren brengt risico met zich mee. Je kunt investeren in een bedrijf, een aandelen fonds samenstellen, investeren in een onderneming van jezelf, of in goederen/materiaal die dan wel iets besparen dan wel iets opleveren.

Stel je rijdt bijvoorbeeld nogal veel, 200.000 km/jaar, en je hebt nu een vadsige benzine wagen die 1:9 loopt, en laten we zeggen 20 cent/km kost aan alleen al brandstof.

Je kunt dan een goedkoop elektrisch karretje aanschaffen voor 80.000 Euro en oneindig veel garantie op alles. En zo'n karretje kost je dan bijv. 5 cent per km.
Al met al een besparing van 15 cent per km, en dus 30k per jaar.

Als je een loden voet hebt, kost ie misschien 10 cent per km, maar ook dan heb je je investering na c.a. 6 jaar al terug.

Wauw, dat was een karige berekening. En ook totaal niet toepasbaar op mezelf. Ik rijd hooguit 15.000 km per jaar, dus pas als ik 120 ben ofzo heb ik m'n Model S investering terug.

Interessanter is zonne energie. Waarom? Omdat de investering kosten lager zijn, en schaalbaar. Je kunt voor 500 Euro een zonne systeem aanschaffen, maar ook voor 5k of 80k, wat jij leuk vind.

Dus stel, je hebt 1000 tot 5000 Euro die op je rekening staat weg te rotten. En het ziet er niet naar uit dat je die de aankomende 25 Jaar nodig hebt.

Kijk, dan kunnen we wat.

Als referentie gebruiken we uiteraard een spaar rekening, en omdat je het 25 jaar niet nodig hebt, is het percentage op het moment rond de 4% vast.

Bij een zonne installatie wordt de berekening wat ingewikkelder, en moeten we een hele zoot met aannames gaan maken.
Maar, omdat we verder toch niks te doen hebben, gaan we die maken... en kijken wat er gebeurt:

Aannames:
1: Ons gehele systeem heeft 10 jaar garantie. Dit wil zeggen als binnen die tijd er een omvormer explodeert, of een paneel houd zomaar op met werken, dan krijgen wij kosteloos een vervanging.
De meeste panelen hebben 10 jaar garantie, en er zijn omvormers met meer dan dat te verkrijgen.
2: De energie prijzen stijgen gestaag met 3% elk jaar wegens geen enkel toekomst perspectief van onze overheid.
3: Onze panelen produceren elk jaar 1% van hun originele wattage minder aan prik Deze aanname maak ik omdat de meeste panelen een vermogens garantie van 80% na 25 jaar hebben. Dus hiermee zitten we er iets onder (namelijk 75%).
4: Je systeem is na aanschaf instantly niks meer waard. (Nogal dramatisch.)
5: Dat we gemiddeld 2 zonne uren hebben per dag.

Wasda?

Een zonne uur (zoals het woord een beetje zegt) is het aantal uur zon. Per dag. En dan dus gemiddeld.

Een paneel produceert niet zoveel energie als er niet direct zon op schijnt. Nu, in de winter zijn de dagen al wat korter, staat de zon ongunstig en is het bewolkt. Gemiddeld hebben we in de winter 1 zonne uur per dag.

Waarom willen we dit weten?

Een paneel wordt gespecificeerd in zijn piek vermogen, WattPiek of Wp. Stel we pakken er eentje van 1000 Wp. (1kWp)
Als je hem dan buiten kwakt in de volle zon, mag verwachten dat er 1000 Watt aan peut uit komt wandelen, of 1kW.
Alle elektronica die het vermogen van het paneel moet omzetten, moet in ieder geval met het piek vermogen over weg kunnen.

Als we hem nu een uurtje laten bakken, hebben we een kilo watt uur opgewekt. (kWh). Namelijk duizend watten, een uur lang.

Normaal betaal je voor een kWh uit het stopcontact c.a. 25 cent.

Woepie.

Als we dus een aanname kunnen maken over het verwacht aantal zonne uren, dan kunnen we een aan name maken over de verwachte opbrengst.

We hebben de wiki zonder bronvermelding: "Met circa 1600 zonuren heeft de kust de meeste zonuren, terwijl de Achterhoek met ongeveer 1450 uur de minste zonneschijn heeft."
We hebben dit wat ongeveer op hetzelfde neer komt.

Gemiddeld 1500 uren per jaar, dat zijn er naar beneden afgerond 4 per dag.

Deze komt met een veel lager gemiddelde, waarvan het mij niet meteen duidelijk is hoe die tabel gemiddeld het getal 1.5 vormt. Die tabel hebben ze hier vandaan gehaald, maar nog steeds... niet duidelijk.

Maar in ieder geval zeggen die, 1.5 zonne uren per dag.

Er is op tweakers een heel forum bezaaid met mensen die al een zonne systeem hebben. Wereldwijd zijn er nog meer mensen, en een deel daarvan is aardig genoeg om bij te houden hoe hun systeem presteert.

Bijv. hier.

Als je naar degene kijkt die hun systeem al langer dan een jaar hebben draaien, kun je een beetje terug rekenen hoeveel zonne uren er zijn geweest.

Zo is er een 4.1kWp systeem, wat in 2012 4100kWh heeft opgeleverd. Dat zijn dan ongeveer 1000 zonne uren geweest, c.a. 2.7 per dag dus. (Valt het al op hoe ik alles naar beneden afrond?)

Of een 2.7kWp met 2300kWh = 850 uur = 2.3 zonne uren.

Deze persoon heeft een 4560 Wp systeem, en komt uit op ongeveer 4300 kWh dit jaar wat op een slordige 2.6 zonuren uit komt.

In 2011 was er kennelijk minder zon, en komen deze berekeningen daadwerkelijk op 1.5 uit. Dus die ga ik pakken. Want we moeten altijd van het absolute slechtste geval uitgaan.
En ik ben optimistisch, ik denk dat er de aankomende 25 jaar nog wel een hittegolfje gaat komen.

Verder, om onszelf niet te vermoeien met mieren-geneuk over sluipverbruik en andere minieme details, geven we ons hele systeem vanaf de panelen tot het 230V maken, een overall efficiëntie van 85% mee. Dat is vrij brak.

De enige variabele die ons nog resteert is de prijs. Een chinees paneel is verkrijgbaar rond de 60 cent per Wp.
Helaas moet hier nog een berg elektronica bij, die ook vrij prijzig is.

Een kant en klaar pakketje (die je nog zelf moet installeren) is met subsidie, die volgend jaar weg is, 5000 Euro voor 3000 Wp.

Nu heb ik een exceletje gefabriekt waar ik al deze doem scenario getallen in heb gezet, en die output dan het volgende grafiekje:
DOOM!

De rode lijn is hoeveel poen er op je spaar rekening staat, de blauwe lijn is hoeveel poen je in totaal op je energie rekening bespaard hebt.

De terug verdien tijd is dus ... nooit.

Nu maak ik van het rente percentage 4.25%, en de zonne uren die van het afgelopen jaar zet ik op 2.5. Ons systeem kost nog steeds 5k na subsidie aftrek, maar heeft een efficientie van 95%.
Het systeem is na 25 jaar niks meer waard, dus je 5k investering is weg.

Dan krijgen we:
Minder DOOM!

Aha, nu is het na 10 jaar interessant om een bak zonne panelen te kopen.

Je ziet op veel sites tekst als: "Terug verdien tijd van +/- 5 jaar."
Daar kom ik met deze sheet ook op, mits ik wat gunstige variabelen invul.
Maar de terug verdien tijd interesseert me niet zo, het moet ook wat opleveren.

Het verwachte rendement bij deze schatting op een systeem van 5000 Euro is ongeveer 5.8% bij een looptijd van 25 jaar. (Pas het rente percentage maar aan.)

Ik hoor graag wat feedback. Zo ben ik geen econoom, dus hoe realistisch is een 3% stijging van de energie prijs?
Hoeveel zonne uren hebben we de afgelopen 10 jaar gehad? Ik kan dit niet zo snel vinden.

Een energie adviesbureau, geeft met een gemiddelde orientatie, sinds 2004 tm 2011, een aantal zonne uren tussen de 800 en 900 per jaar. Wat dus tussen de 2.2 en 2.5 per dag ligt.

Aanpassing 1:
Ik heb de comment van sypie verwerkt:

Geld op je spaar rekening kun je niet bij, gedurende die 25 jaar, en de rente ook niet.
Als je bij de "rente" op je PV panelen (in de vorm van besparing) ook niet kunt, kun je die gedurende 25 jaar op een rekening zetten (die op zijn beurt weer rente heeft.)

Verder heb ik vermogens belasting toegevoegd op het vermogen wat op een rekening verschijnt. Da's na 1 jaar dus 5000 in het geval van sparen, en bijv. iets van 600 Euro in het geval van een PV installatie.

Mijn worst case scenario ziet er nu nog steeds grimmig uit, maar het duurt nu niet meer oneindig lang voor het break even point.

Die van mux, waar alles na 10 jaar dit doet:
Mux over EOL Electronica
....is ook niet rooskleurig.

Aanpassing 2

De CBS prijzen sinds 1996 heb ik er bij gezet, in een ander tab blad. Deze zijn sinds 1996 ongeveer 7% gestegen elk jaar. Dus ik heb nu een 5% stijging per jaar aan genomen.

Verder zit de vermindering energie belasting er nu als een vast bedrag in. Die was van 2009-nu 379 Euro, en was in 2008 236 Euro. [bron]

Ik heb het bedrag nu op 5200 Euro staan, voor een 4.4kWp systeem.

Uitgaande van 850 zonne uren, 2.3 per dag gemiddeld, zou het na 12 jaar interessant zijn om zonne panelen aan te schaffen.

Dit zou in Mux zijn scenario... niet zo goed zijn.


Link naar excelletje.ods
Link naar excelletje.xlsx

Link naar excelletje.ods
Link naar excelletje.xlsx