BaseTinyFirmware/IAR/Debug/List/NIMHcharge.s90

   1 ///////////////////////////////////////////////////////////////////////////////\r
   2 //                                                                            /\r
   3 // IAR Atmel AVR C/C++ Compiler V4.30F/W32              12/Mar/2008  23:01:38 /\r
   4 // Copyright 1996-2007 IAR Systems. All rights reserved.                      /\r
   5 //                                                                            /\r
   6 //    Source file  =  C:\home\kevin\pub\src\bc100_cal\IAR\NIMHcharge.c        /\r
   7 //    Command line =  C:\home\kevin\pub\src\bc100_cal\IAR\NIMHcharge.c        /\r
   8 //                    --cpu=tiny861 -ms -o C:\home\kevin\pub\src\bc100_cal\IA /\r
   9 //                    R\Debug\Obj\ -lC C:\home\kevin\pub\src\bc100_cal\IAR\De /\r
  10 //                    bug\List\ -lB C:\home\kevin\pub\src\bc100_cal\IAR\Debug /\r
  11 //                    \List\ --initializers_in_flash -z2 --no_cse             /\r
  12 //                    --no_inline --no_code_motion --no_cross_call            /\r
  13 //                    --no_clustering --no_tbaa --debug                       /\r
  14 //                    -DENABLE_BIT_DEFINITIONS -e --require_prototypes -I     /\r
  15 //                    "C:\Program Files\IAR Systems\Embedded Workbench        /\r
  16 //                    4.0\avr\INC\" -I "C:\Program Files\IAR                  /\r
  17 //                    Systems\Embedded Workbench 4.0\avr\INC\CLIB\"           /\r
  18 //                    --eeprom_size 512                                       /\r
  19 //    List file    =  C:\home\kevin\pub\src\bc100_cal\IAR\Debug\List\NIMHchar /\r
  20 //                    ge.s90                                                  /\r
  21 //                                                                            /\r
  22 //                                                                            /\r
  23 ///////////////////////////////////////////////////////////////////////////////\r
  24 \r
  25         NAME NIMHcharge\r
  26 \r
  27         RSEG CSTACK:DATA:NOROOT(0)\r
  28         RSEG RSTACK:DATA:NOROOT(0)\r
  29 \r
  30         EXTERN ?EPILOGUE_B2_L09\r
  31         EXTERN ?PROLOGUE2_L09\r
  32         EXTERN ?SS_DIVMOD_L02\r
  33         EXTERN ?US_DIVMOD_L02\r
  34         EXTERN __eeget8_16\r
  35 \r
  36         PUBLIC Charge\r
  37         PUBWEAK __?EEARH\r
  38         PUBWEAK __?EEARL\r
  39         PUBWEAK __?EECR\r
  40         PUBWEAK __?EEDR\r
  41 \r
  42         EXTERN PWM_Start\r
  43         EXTERN Time_Set\r
  44         EXTERN ConstantCurrent\r
  45         EXTERN PWM_Stop\r
  46         EXTERN BattActive\r
  47         EXTERN BattControl\r
  48         EXTERN BattData\r
  49         EXTERN ChargeParameters\r
  50         EXTERN CurrentState\r
  51         EXTERN HaltParameters\r
  52 \r
  53 // C:\home\kevin\pub\src\bc100_cal\IAR\NIMHcharge.c\r
  54 //    1 /* This file has been prepared for Doxygen automatic documentation generation.*/\r
  55 //    2 /*! \file *********************************************************************\r
  56 //    3  *\r
  57 //    4  * \brief\r
  58 //    5  *      Charge state function for NiMH batteries\r
  59 //    6  *\r
  60 //    7  *      Contains the charge state function, in which the NiMH charging\r
  61 //    8  *      algorithm is, plus the associated functions.\r
  62 //    9  *\r
  63 //   10  * \par Application note:\r
  64 //   11  *      AVR463: Charging NiMH Batteries with BC100 \n\r
  65 //   12  *\r
  66 //   13  * \par Documentation\r
  67 //   14  *      For comprehensive code documentation, supported compilers, compiler \r
  68 //   15  *      settings and supported devices see readme.html\r
  69 //   16  *\r
  70 //   17  * \author\r
  71 //   18  *      Atmel Corporation: http://www.atmel.com \n\r
  72 //   19  *      Support email: avr@atmel.com\r
  73 //   20  *\r
  74 //   21  * \r
  75 //   22  * $Name$\r
  76 //   23  * $Revision: 2255 $\r
  77 //   24  * $RCSfile$\r
  78 //   25  * $URL: http://svn.norway.atmel.com/AppsAVR8/avr463_Charging_NiMH_Batteries_with_BC100/trunk/code/IAR/NIMHcharge.c $\r
  79 //   26  * $Date: 2007-08-09 14:47:58 +0200 (to, 09 aug 2007) $\n\r
  80 //   27  ******************************************************************************/\r
  81 //   28 \r
  82 //   29 #include <ioavr.h>\r
  83 //   30 \r
  84 //   31 #include "enums.h"\r
  85 //   32 #include "structs.h"\r
  86 //   33 \r
  87 //   34 #include "battery.h"\r
  88 //   35 #include "charge.h"\r
  89 //   36 #include "chargefunc.h"\r
  90 //   37 #include "main.h"\r
  91 //   38 #include "menu.h"\r
  92 //   39 #include "NIMHspecs.h"\r
  93 //   40 #include "PWM.h"\r
  94 //   41 #include "time.h"\r
  95 //   42 \r
  96 //   43 #ifndef NIMH\r
  97 //   44 #error NIMH not defined in main.h!\r
  98 //   45 #endif // NIMH\r
  99 //   46 \r
 100 //   47 \r
 101 //   48 //******************************************************************************\r
 102 //   49 // Functions\r
 103 //   50 //******************************************************************************\r
 104 //   51 /*! \brief Controls the charging.\r
 105 //   52  *\r
 106 //   53  * This function contains the charging algorithm itself, divided into stages.\n\r
 107 //   54  * For each stage the PWM may be started/stopped, and the timer, \r
 108 //   55  * halt-requirements and charge parameters may be set.\n\r
 109 //   56  * The charging functions return whatever state is next, and as long as no\r
 110 //   57  * errors occur this is the next charging stage.\r
 111 //   58  *\r
 112 //   59  * \note If more stages are needed simply define more states in menu.h, include\r
 113 //   60  * them in \ref menu_state[] in menu.c, then add the cases to this function.\r
 114 //   61  *\r
 115 //   62  * \note This algorithm is for NiMH batteries.\r
 116 //   63  */\r
 117 \r
 118         RSEG CODE:CODE:NOROOT(1)\r
 119 //   64 unsigned char Charge(unsigned char inp)\r
 120 Charge:\r
 121 //   65 {\r
 122         RCALL   ?PROLOGUE2_L09\r
 123         MOV     R25, R16\r
 124 //   66         unsigned char NextState;\r
 125 //   67 \r
 126 //   68         switch (CurrentState) {\r
 127         LDS     R16, CurrentState\r
 128         SUBI    R16, 30\r
 129         BREQ    ??Charge_0\r
 130         SUBI    R16, 20\r
 131         BREQ    ??Charge_1\r
 132         SUBI    R16, 10\r
 133         BRNE    $+2+2\r
 134         RJMP    ??Charge_2\r
 135         SUBI    R16, 10\r
 136         BRNE    $+2+2\r
 137         RJMP    ??Charge_3\r
 138         RJMP    ??Charge_4\r
 139 //   69         // First stage is a prequalification. Attempt to charge battery to 1 V,\r
 140 //   70         // using a 0.1 C current, within 2 minutes.\r
 141 //   71         // If this fails, the battery is likely damaged.\r
 142 //   72         // If it succeeds, start a fast charge.\r
 143 //   73         case ST_PREQUAL:\r
 144 //   74                 \r
 145 //   75                 // Set up charge current and next state.\r
 146 //   76                 ChargeParameters.Current = BattData.Capacity / 10;\r
 147 ??Charge_0:\r
 148         LDI     R30, LOW(BattData)\r
 149         LDI     R31, (BattData) >> 8\r
 150         LDD     R16, Z+4\r
 151         LDD     R17, Z+5\r
 152         LDI     R20, 10\r
 153         LDI     R21, 0\r
 154         RCALL   ?US_DIVMOD_L02\r
 155         LDI     R30, LOW(ChargeParameters)\r
 156         LDI     R31, (ChargeParameters) >> 8\r
 157         STD     Z+2, R16\r
 158         STD     Z+3, R17\r
 159 //   77                 ChargeParameters.NextState = ST_FASTCHARGE;\r
 160         LDI     R16, 50\r
 161         STS     (ChargeParameters + 4), R16\r
 162 //   78                 \r
 163 //   79                 // Halt charge on voltage limit or timeout.\r
 164 //   80                 // Timeout means battery exhaustion.\r
 165 //   81                 HaltParameters.HaltFlags = (HALT_VOLTAGE_MAX | HALT_TIME |\r
 166 //   82                                             HALT_FLAG_EXHAUSTION);\r
 167         LDI     R16, 50\r
 168         STS     HaltParameters, R16\r
 169 //   83                 \r
 170 //   84                 // Set up voltage limit and temperature limits.\r
 171 //   85                 HaltParameters.VoltageMax = BAT_VOLTAGE_PREQUAL;\r
 172         LDI     R16, 184\r
 173         LDI     R17, 11\r
 174         LDI     R30, LOW(HaltParameters)\r
 175         LDI     R31, (HaltParameters) >> 8\r
 176         STD     Z+3, R16\r
 177         STD     Z+4, R17\r
 178 //   86                 HaltParameters.TemperatureMin = BAT_TEMPERATURE_MIN;\r
 179         LDI     R16, 5\r
 180         LDI     R17, 0\r
 181         LDI     R30, LOW(HaltParameters)\r
 182         LDI     R31, (HaltParameters) >> 8\r
 183         STD     Z+9, R16\r
 184         STD     Z+10, R17\r
 185 //   87                 HaltParameters.TemperatureMax = 35;\r
 186         LDI     R16, 35\r
 187         LDI     R17, 0\r
 188         LDI     R30, LOW(HaltParameters)\r
 189         LDI     R31, (HaltParameters) >> 8\r
 190         STD     Z+7, R16\r
 191         STD     Z+8, R17\r
 192 //   88                 \r
 193 //   89                 // Reset temperature measurement for HaltNow().\r
 194 //   90                 HaltParameters.LastNTC = 0;\r
 195         LDI     R16, 0\r
 196         LDI     R17, 0\r
 197         LDI     R30, LOW(HaltParameters)\r
 198         LDI     R31, (HaltParameters) >> 8\r
 199         STD     Z+15, R16\r
 200         STD     Z+16, R17\r
 201 //   91                 \r
 202 //   92                 // Start PWM and charge timer before calling the charge function.\r
 203 //   93                 PWM_Start();\r
 204         RCALL   PWM_Start\r
 205 //   94                 Time_Set(TIMER_CHG, BAT_TIME_PREQUAL, 0, 0);\r
 206         LDI     R20, 0\r
 207         LDI     R17, 0\r
 208         LDI     R18, 2\r
 209         LDI     R19, 0\r
 210         LDI     R16, 1\r
 211         RCALL   Time_Set\r
 212 //   95                 \r
 213 //   96                 // Call charge function, get next state.\r
 214 //   97                 NextState = ConstantCurrent();\r
 215         RCALL   ConstantCurrent\r
 216         MOV     R24, R16\r
 217         RJMP    ??Charge_5\r
 218 //   98         break;\r
 219 //   99 \r
 220 //  100 \r
 221 //  101         // Second stage is a fast charge. Charge at 1.0 C for at most 1.5 hours,\r
 222 //  102         // until either rate of temperature increase or voltage reaches limit, or\r
 223 //  103         // the voltage drops sufficiently.\r
 224 //  104         // Timeout doesn't mean battery exhaustion now.\r
 225 //  105         case ST_FASTCHARGE:\r
 226 //  106 \r
 227 //  107                 // Set up charge current and next state.\r
 228 //  108                 ChargeParameters.Current = BattData.Capacity;\r
 229 ??Charge_1:\r
 230         LDI     R30, LOW(BattData)\r
 231         LDI     R31, (BattData) >> 8\r
 232         LDD     R16, Z+4\r
 233         LDD     R17, Z+5\r
 234         LDI     R30, LOW(ChargeParameters)\r
 235         LDI     R31, (ChargeParameters) >> 8\r
 236         STD     Z+2, R16\r
 237         STD     Z+3, R17\r
 238 //  109                 ChargeParameters.NextState = ST_LOWRATECHARGE;\r
 239         LDI     R16, 60\r
 240         STS     (ChargeParameters + 4), R16\r
 241 //  110                 \r
 242 //  111                 // Halt charge on voltage limit, timeout, voltage drop or rate of \r
 243 //  112                 // temperature increase.\r
 244 //  113                 HaltParameters.HaltFlags = (HALT_VOLTAGE_MAX | HALT_TIME |\r
 245 //  114                                             HALT_VOLTAGE_DROP | HALT_TEMPERATURE_RISE);\r
 246         LDI     R16, 27\r
 247         STS     HaltParameters, R16\r
 248 //  115                 \r
 249 //  116                 // Set up limits for voltage, voltage drop, temperature and rate of \r
 250 //  117                 // temperature increase (1 degree C per minute).\r
 251 //  118                 HaltParameters.VoltageMax = BAT_VOLTAGE_MAX;\r
 252         LDI     R16, 192\r
 253         LDI     R17, 18\r
 254         LDI     R30, LOW(HaltParameters)\r
 255         LDI     R31, (HaltParameters) >> 8\r
 256         STD     Z+3, R16\r
 257         STD     Z+4, R17\r
 258 //  119                 HaltParameters.VoltageDrop = BAT_VOLTAGE_DROP;\r
 259         LDI     R16, 45\r
 260         LDI     R17, 0\r
 261         LDI     R30, LOW(HaltParameters)\r
 262         LDI     R31, (HaltParameters) >> 8\r
 263         STD     Z+1, R16\r
 264         STD     Z+2, R17\r
 265 //  120                 HaltParameters.TemperatureMax = BAT_TEMPERATURE_MAX;\r
 266         LDI     R16, 50\r
 267         LDI     R17, 0\r
 268         LDI     R30, LOW(HaltParameters)\r
 269         LDI     R31, (HaltParameters) >> 8\r
 270         STD     Z+7, R16\r
 271         STD     Z+8, R17\r
 272 //  121                 HaltParameters.TemperatureRise = 1;\r
 273         LDI     R16, 1\r
 274         LDI     R17, 0\r
 275         LDI     R30, LOW(HaltParameters)\r
 276         LDI     R31, (HaltParameters) >> 8\r
 277         STD     Z+11, R16\r
 278         STD     Z+12, R17\r
 279 //  122                 \r
 280 //  123                 // Reset maximum voltage measurement for HaltNow().\r
 281 //  124                 HaltParameters.VBATMax = 0;\r
 282         LDI     R16, 0\r
 283         LDI     R17, 0\r
 284         LDI     R30, LOW(HaltParameters)\r
 285         LDI     R31, (HaltParameters) >> 8\r
 286         STD     Z+13, R16\r
 287         STD     Z+14, R17\r
 288 //  125 \r
 289 //  126                 // Start timer, PWM should still be running.\r
 290 //  127                 Time_Set(TIMER_CHG, BattData.MaxTime, 0, 0);\r
 291         LDI     R20, 0\r
 292         LDI     R17, 0\r
 293         LDI     R30, LOW(BattData)\r
 294         LDI     R31, (BattData) >> 8\r
 295         LDD     R18, Z+8\r
 296         LDD     R19, Z+9\r
 297         LDI     R16, 1\r
 298         RCALL   Time_Set\r
 299 //  128 \r
 300 //  129                 // Call charge function, get next state.\r
 301 //  130                 NextState = ConstantCurrent();\r
 302         RCALL   ConstantCurrent\r
 303         MOV     R24, R16\r
 304         RJMP    ??Charge_5\r
 305 //  131         break;\r
 306 //  132 \r
 307 //  133 \r
 308 //  134         // Last stage is a trickle charge. Charge at 0.1 C for at most 30 minutes,\r
 309 //  135         // until either rate of temperature increase or voltage reaches limit.\r
 310 //  136         case ST_LOWRATECHARGE:\r
 311 //  137                 \r
 312 //  138                 // Set up charge current and next state.\r
 313 //  139                 ChargeParameters.Current = BattData.Capacity / 10;\r
 314 ??Charge_2:\r
 315         LDI     R30, LOW(BattData)\r
 316         LDI     R31, (BattData) >> 8\r
 317         LDD     R16, Z+4\r
 318         LDD     R17, Z+5\r
 319         LDI     R20, 10\r
 320         LDI     R21, 0\r
 321         RCALL   ?US_DIVMOD_L02\r
 322         LDI     R30, LOW(ChargeParameters)\r
 323         LDI     R31, (ChargeParameters) >> 8\r
 324         STD     Z+2, R16\r
 325         STD     Z+3, R17\r
 326 //  140                 ChargeParameters.NextState = ST_ENDCHARGE;\r
 327         LDI     R16, 70\r
 328         STS     (ChargeParameters + 4), R16\r
 329 //  141                 \r
 330 //  142                 // Halt charge on voltage limit, timeout or temperature rise.\r
 331 //  143                 // Use the same requirements as during the last stage (ST_FASTCHARGE).\r
 332 //  144                 HaltParameters.HaltFlags = (HALT_VOLTAGE_MAX | HALT_TIME |\r
 333 //  145                                             HALT_TEMPERATURE_RISE);\r
 334         LDI     R16, 26\r
 335         STS     HaltParameters, R16\r
 336 //  146 \r
 337 //  147                 // Start timer, 30 minutes.\r
 338 //  148                 Time_Set(TIMER_CHG, 30, 0, 0);\r
 339         LDI     R20, 0\r
 340         LDI     R17, 0\r
 341         LDI     R18, 30\r
 342         LDI     R19, 0\r
 343         LDI     R16, 1\r
 344         RCALL   Time_Set\r
 345 //  149                 \r
 346 //  150                 // Call charge function, get next state.\r
 347 //  151                 NextState = ConstantCurrent();\r
 348         RCALL   ConstantCurrent\r
 349         MOV     R24, R16\r
 350         RJMP    ??Charge_5\r
 351 //  152         break;\r
 352 //  153 \r
 353 //  154 \r
 354 //  155         // Charging is done!\r
 355 //  156         case ST_ENDCHARGE:\r
 356 //  157 \r
 357 //  158                 // Stop the PWM output and flag battery as charged.\r
 358 //  159                 PWM_Stop();\r
 359 ??Charge_3:\r
 360         RCALL   PWM_Stop\r
 361 //  160                 BattData.Charged = TRUE;\r
 362         LDI     R30, LOW(BattData)\r
 363         LDI     R31, (BattData) >> 8\r
 364         LD      R16, Z\r
 365         ORI     R16, 0x02\r
 366         ST      Z, R16\r
 367 //  161                 \r
 368 //  162                 // If the other battery is enabled go to ST_BATCON, otherwise\r
 369 //  163                 // go to ST_SLEEP.\r
 370 //  164                 if (BattControl[(BattActive+1)%2].Enabled) {\r
 371         LDS     R16, BattActive\r
 372         LDI     R17, 0\r
 373         SUBI    R16, 255\r
 374         SBCI    R17, 255\r
 375         LDI     R20, 2\r
 376         LDI     R21, 0\r
 377         RCALL   ?SS_DIVMOD_L02\r
 378         LDI     R18, LOW(BattControl)\r
 379         LDI     R19, (BattControl) >> 8\r
 380         ADD     R18, R20\r
 381         ADC     R19, R21\r
 382         MOVW    R21:R20, R19:R18\r
 383         RCALL   __eeget8_16\r
 384         ANDI    R16, 0x01\r
 385         TST     R16\r
 386         BREQ    ??Charge_6\r
 387 //  165                         NextState = ST_BATCON;\r
 388         LDI     R24, 20\r
 389         RJMP    ??Charge_5\r
 390 //  166                 } else {\r
 391 //  167                         NextState = ST_SLEEP;\r
 392 ??Charge_6:\r
 393         LDI     R24, 40\r
 394         RJMP    ??Charge_5\r
 395 //  168                 }               \r
 396 //  169         break;\r
 397 //  170 \r
 398 //  171 \r
 399 //  172         default:  // Shouldn't end up here. Reinitialize for safety.\r
 400 //  173                 NextState = ST_INIT;\r
 401 ??Charge_4:\r
 402         LDI     R24, 10\r
 403 //  174                 break;\r
 404 //  175         }\r
 405 //  176 \r
 406 //  177         // Return the next state to main().\r
 407 //  178         return(NextState);\r
 408 ??Charge_5:\r
 409         MOV     R16, R24\r
 410         LDI     R30, 2\r
 411         RJMP    ?EPILOGUE_B2_L09\r
 412 //  179 }\r
 413 \r
 414         ASEGN ABSOLUTE:DATA:NOROOT,01cH\r
 415 __?EECR:\r
 416 \r
 417         ASEGN ABSOLUTE:DATA:NOROOT,01dH\r
 418 __?EEDR:\r
 419 \r
 420         ASEGN ABSOLUTE:DATA:NOROOT,01eH\r
 421 __?EEARL:\r
 422 \r
 423         ASEGN ABSOLUTE:DATA:NOROOT,01fH\r
 424 __?EEARH:\r
 425 \r
 426         END\r
 427 // \r
 428 // 356 bytes in segment CODE\r
 429 // \r
 430 // 356 bytes of CODE memory\r
 431 //\r
 432 //Errors: none\r
 433 //Warnings: none\r