Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/firmware/SES/Src/precharge.c

    r3 r1  
    66#include "precharge.h"
    77
    8 #define DELAYS_NUM                      7U
     8#define DELAYS_NUM                      43U
    99
    1010extern void (*MOSFETS_Management)(void);
    … …  
    2828#endif
    2929{
    30         const int32_t MHz = 1000000U;
    3130        static int stage = 0;
    3231        static int cnt = 0;
    3332        static int mal = 0;
    34                                                                 //   DAC = 0   DAC = 3V
    35         const int32_t delay_µs[DELAYS_NUM] = {   3,                3,     // 0, 1         - 6710µs is MAX @320kHz, [0,1,2,3] = 3µs
    36                                                                                300,                3,     // 2, 3
    37                                                                                     50,            3,     // 4, 5
    38                                                                                     50                            // 6
    39                                                                              };
    40         const int32_t delay_cnt[DELAYS_NUM] = { (delay_µs[ 0 ] * CURRENT_INTEGRAL_FREQ) / MHz,
    41                                                                                     (delay_µs[ 1 ] * CURRENT_INTEGRAL_FREQ) / MHz,
    42                                                                                     (delay_µs[ 2 ] * CURRENT_INTEGRAL_FREQ) / MHz,
    43                                                                                     (delay_µs[ 3 ] * CURRENT_INTEGRAL_FREQ) / MHz,
    44                                                                                     (delay_µs[ 4 ] * CURRENT_INTEGRAL_FREQ) / MHz,
    45                                                                                     (delay_µs[ 5 ] * CURRENT_INTEGRAL_FREQ) / MHz,
    46                                                                                     (delay_µs[ 6 ] * CURRENT_INTEGRAL_FREQ) / MHz,
    47                                                                               };
     33                                                                //    DAC = 0  DAC = 3V
     34        const int delay_µs[DELAYS_NUM] = {      50,                2,     // 0, 1         - 6710µs is MAX @320kHz
     35                                                                                50,                2,     // 2, 3
     36                                                                                50,                2,     // 4, 5
     37                                                                                50,                2,     // 6, 7
     38                                                                                50,                2,     // 9, 9
     39                                                                                50,                2,     // 10, 11
     40                                                                                50,                2,     // 12, 13
     41                                                                                50,                2,     // 14, 15
     42                                                                                50,                2,     // 16, 17
     43                                                                                50,                2,     // 18, 19
     44                                                                                50,                2,     // 20, 21
     45                                                                                50,                2,     // 22, 23
     46                                                                                50,                2,     // 24, 25
     47                                                                                50,                2,     // 26, 27
     48                                                                                50,                2,     // 28, 29
     49                                                                                50,                2,     // 30, 31
     50                                                                                50,                2,     // 32, 33
     51                                                                                50,                2,     // 34, 35
     52                                                                                50,                2,     // 36, 37
     53                                                                                50,                2,     // 38, 39
     54                                                                                50,                2,     // 40, 41
     55                                                                                50};                      // 42
     56        const int delay_cnt[DELAYS_NUM] = { (delay_µs[ 0] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     57                                                                                (delay_µs[ 1] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     58                                                                                (delay_µs[ 2] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     59                                                                                (delay_µs[ 3] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     60                                                                                (delay_µs[ 4] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     61                                                                                (delay_µs[ 5] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     62                                                                                (delay_µs[ 6] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     63                                                                                (delay_µs[ 7] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     64                                                                                (delay_µs[ 8] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     65                                                                                (delay_µs[ 9] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     66                                                                                (delay_µs[10] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     67                                                                                (delay_µs[11] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     68                                                                                (delay_µs[12] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     69                                                                                (delay_µs[13] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     70                                                                                (delay_µs[14] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     71                                                                                (delay_µs[15] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     72                                                                                (delay_µs[16] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     73                                                                                (delay_µs[17] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     74                                                                                (delay_µs[18] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     75                                                                                (delay_µs[19] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     76                                                                                (delay_µs[20] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     77                                                                                (delay_µs[21] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     78                                                                                (delay_µs[22] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     79                                                                                (delay_µs[23] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     80                                                                                (delay_µs[24] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     81                                                                                (delay_µs[25] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     82                                                                                (delay_µs[26] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     83                                                                                (delay_µs[27] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     84                                                                                (delay_µs[28] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     85                                                                                (delay_µs[29] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     86                                                                                (delay_µs[30] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     87                                                                                (delay_µs[31] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     88                                                                                (delay_µs[32] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     89                                                                                (delay_µs[33] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     90                                                                                (delay_µs[34] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     91                                                                                (delay_µs[35] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     92                                                                                (delay_µs[36] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     93                                                                                (delay_µs[37] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     94                                                                                (delay_µs[38] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     95                                                                                (delay_µs[39] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     96                                                                                (delay_µs[40] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     97                                                                                (delay_µs[41] * CURRENT_INTEGRAL_FREQ) / 1000000U,
     98                                                                                (delay_µs[42] * CURRENT_INTEGRAL_FREQ) / 1000000U
     99                                                                          };
    48100         
    49101        switch(stage)
    … …  
    54106                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
    55107
    56                         if (cnt++ >= delay_cnt[0])      // 1c
     108                        if (cnt++ >= delay_cnt[0])
    57109                        {
    58110                                cnt = 0;
    … …  
    62114
    63115                case 1:
    64                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V >> 1;
    65                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V >> 1;
    66 
    67                         if (cnt++ >= delay_cnt[1])      // 1c
    68                         {
    69                                 cnt = 0;
    70                                 stage++;
    71                         }
    72                         break;
     116                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     117                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     118
     119                        if (cnt++ >= delay_cnt[1])
     120                        {
     121                                cnt = 0;
     122                                stage++;
     123                        }
     124                        break;
     125
     126                /*case 2:
     127                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     128                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     129
     130                        if (cnt++ >= delay_cnt[2])
     131                        {
     132                                cnt = 0;
     133                                stage++;
     134                        }
     135                        break;
     136
     137                case 3:
     138                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     139                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     140
     141                        if (cnt++ >= delay_cnt[3])
     142                        {
     143                                cnt = 0;
     144                                stage++;
     145                        }
     146                        break;
     147
     148                case 4:
     149                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     150                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     151
     152                        if (cnt++ >= delay_cnt[4])
     153                        {
     154                                cnt = 0;
     155                                stage++;
     156                        }
     157                        break;
     158
     159                case 5:
     160                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     161                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     162
     163                        if (cnt++ >= delay_cnt[5])
     164                        {
     165                                cnt = 0;
     166                                stage++;
     167                        }
     168                        break;
     169
     170                case 6:
     171                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     172                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     173
     174                        if (cnt++ >= delay_cnt[6])
     175                        {
     176                                cnt = 0;
     177                                stage++;
     178                        }
     179                        break;
     180
     181                case 7:
     182                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     183                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     184
     185                        if (cnt++ >= delay_cnt[7])
     186                        {
     187                                cnt = 0;
     188                                stage++;
     189                        }
     190                        break;
     191
     192                case 8:
     193                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     194                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     195
     196                        if (cnt++ >= delay_cnt[8])
     197                        {
     198                                cnt = 0;
     199                                stage++;
     200                        }
     201                        break;
     202
     203                case 9:
     204                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     205                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     206
     207                        if (cnt++ >= delay_cnt[9])
     208                        {
     209                                cnt = 0;
     210                                stage++;
     211                        }
     212                        break;
     213
     214                case 10:
     215                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     216                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     217
     218                        if (cnt++ >= delay_cnt[10])
     219                        {
     220                                cnt = 0;
     221                                stage++;
     222                        }
     223                        break;
     224
     225                case 11:
     226                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     227                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     228
     229                        if (cnt++ >= delay_cnt[11])
     230                        {
     231                                cnt = 0;
     232                                stage++;
     233                        }
     234                        break;
     235
     236                case 12:
     237                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     238                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     239
     240                        if (cnt++ >= delay_cnt[12])
     241                        {
     242                                cnt = 0;
     243                                stage++;
     244                        }
     245                        break;
     246
     247                case 13:
     248                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     249                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     250
     251                        if (cnt++ >= delay_cnt[13])
     252                        {
     253                                cnt = 0;
     254                                stage++;
     255                        }
     256                        break;
     257
     258                case 14:
     259                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     260                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     261
     262                        if (cnt++ >= delay_cnt[14])
     263                        {
     264                                cnt = 0;
     265                                stage++;
     266                        }
     267                        break;
     268
     269                case 15:
     270                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     271                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     272
     273                        if (cnt++ >= delay_cnt[15])
     274                        {
     275                                cnt = 0;
     276                                stage++;
     277                        }
     278                        break;
     279
     280                case 16:
     281                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     282                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     283
     284                        if (cnt++ >= delay_cnt[16])
     285                        {
     286                                cnt = 0;
     287                                stage++;
     288                        }
     289                        break;
     290
     291                case 17:
     292                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     293                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     294
     295                        if (cnt++ >= delay_cnt[17])
     296                        {
     297                                cnt = 0;
     298                                stage++;
     299                        }
     300                        break;
     301
     302                case 18:
     303                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     304                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     305
     306                        if (cnt++ >= delay_cnt[18])
     307                        {
     308                                cnt = 0;
     309                                stage++;
     310                        }
     311                        break;
     312
     313                case 19:
     314                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     315                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     316
     317                        if (cnt++ >= delay_cnt[19])
     318                        {
     319                                cnt = 0;
     320                                stage++;
     321                        }
     322                        break;
     323
     324                case 20:
     325                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     326                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     327
     328                        if (cnt++ >= delay_cnt[20])
     329                        {
     330                                cnt = 0;
     331                                stage++;
     332                        }
     333                        break;
     334
     335                case 21:
     336                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     337                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     338
     339                        if (cnt++ >= delay_cnt[21])
     340                        {
     341                                cnt = 0;
     342                                stage++;
     343                        }
     344                        break;
     345
     346                case 22:
     347                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     348                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     349
     350                        if (cnt++ >= delay_cnt[22])
     351                        {
     352                                cnt = 0;
     353                                stage++;
     354                        }
     355                        break;
     356
     357                case 23:
     358                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     359                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     360
     361                        if (cnt++ >= delay_cnt[23])
     362                        {
     363                                cnt = 0;
     364                                stage++;
     365                        }
     366                        break;
     367
     368                case 24:
     369                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     370                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     371
     372                        if (cnt++ >= delay_cnt[24])
     373                        {
     374                                cnt = 0;
     375                                stage++;
     376                        }
     377                        break;
     378
     379                case 25:
     380                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     381                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     382
     383                        if (cnt++ >= delay_cnt[25])
     384                        {
     385                                cnt = 0;
     386                                stage++;
     387                        }
     388                        break;
     389
     390                case 26:
     391                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     392                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     393
     394                        if (cnt++ >= delay_cnt[26])
     395                        {
     396                                cnt = 0;
     397                                stage++;
     398                        }
     399                        break;
     400
     401                case 27:
     402                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     403                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     404
     405                        if (cnt++ >= delay_cnt[27])
     406                        {
     407                                cnt = 0;
     408                                stage++;
     409                        }
     410                        break;
     411
     412                case 28:
     413                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     414                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     415
     416                        if (cnt++ >= delay_cnt[28])
     417                        {
     418                                cnt = 0;
     419                                stage++;
     420                        }
     421                        break;
     422
     423                case 29:
     424                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     425                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     426
     427                        if (cnt++ >= delay_cnt[29])
     428                        {
     429                                cnt = 0;
     430                                stage++;
     431                        }
     432                        break;
     433
     434                case 30:
     435                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     436                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     437
     438                        if (cnt++ >= delay_cnt[30])
     439                        {
     440                                cnt = 0;
     441                                stage++;
     442                        }
     443                        break;
     444
     445                case 31:
     446                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     447                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     448
     449                        if (cnt++ >= delay_cnt[31])
     450                        {
     451                                cnt = 0;
     452                                stage++;
     453                        }
     454                        break;
     455
     456                case 32:
     457                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     458                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     459
     460                        if (cnt++ >= delay_cnt[32])
     461                        {
     462                                cnt = 0;
     463                                stage++;
     464                        }
     465                        break;
     466
     467                case 33:
     468                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     469                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     470
     471                        if (cnt++ >= delay_cnt[33])
     472                        {
     473                                cnt = 0;
     474                                stage++;
     475                        }
     476                        break;
     477
     478                case 34:
     479                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     480                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     481
     482                        if (cnt++ >= delay_cnt[34])
     483                        {
     484                                cnt = 0;
     485                                stage++;
     486                        }
     487                        break;
     488
     489                case 35:
     490                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     491                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     492
     493                        if (cnt++ >= delay_cnt[35])
     494                        {
     495                                cnt = 0;
     496                                stage++;
     497                        }
     498                        break;
     499
     500                case 36:
     501                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     502                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     503
     504                        if (cnt++ >= delay_cnt[36])
     505                        {
     506                                cnt = 0;
     507                                stage++;
     508                        }
     509                        break;
     510
     511                case 37:
     512                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     513                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     514
     515                        if (cnt++ >= delay_cnt[37])
     516                        {
     517                                cnt = 0;
     518                                stage++;
     519                        }
     520                        break;
     521
     522                case 38:
     523                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     524                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     525
     526                        if (cnt++ >= delay_cnt[38])
     527                        {
     528                                cnt = 0;
     529                                stage++;
     530                        }
     531                        break;
     532
     533                case 39:
     534                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     535                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     536
     537                        if (cnt++ >= delay_cnt[39])
     538                        {
     539                                cnt = 0;
     540                                stage++;
     541                        }
     542                        break;
     543
     544                case 40:
     545                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     546                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
     547
     548                        if (cnt++ >= delay_cnt[40])
     549                        {
     550                                cnt = 0;
     551                                stage++;
     552                        }
     553                        break;
     554
     555                case 41:
     556                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     557                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
     558
     559                        if (cnt++ >= delay_cnt[41])
     560                        {
     561                                cnt = 0;
     562                                stage++;
     563                        }
     564                        break;*/
    73565
    74566                case 2:
    … …  
    76568                        *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
    77569
    78                         if (cnt++ >= delay_cnt[2])      // 300c
    79                         {
    80                                 cnt = 0;
    81                                 stage++;
    82                         }
    83                         break;
    84 
    85                 case 3:
    86                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = 0xBFF;//DAC_3V;
    87                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = 0xBFF;//DAC_3V;
    88 
    89                         if (cnt++ >= delay_cnt[3])      // 1c
    90                         {
    91                                 cnt = 0;
    92                                 stage++;
    93                         }
    94                         break;
    95 
    96                 case 4:
    97                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
    98                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
    99 
    100                         if (cnt++ >= delay_cnt[4])      // 50c
    101                         {
    102                                 cnt = 0;
    103                                 stage++;
    104                         }
    105                         break;
    106 
    107                 case 5:
    108                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
    109                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_3V;
    110 
    111                         if (cnt++ >= delay_cnt[5])      // 1c
    112                         {
    113                                 cnt = 0;
    114                                 stage++;
    115                         }
    116                         break;
    117 
    118                 case 6:
    119                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_A_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
    120                         *(__IO uint32_t *)((uint32_t)DAC_HANDLE.Instance + DAC_CH_B_ALIGNMENT(DAC_ALIGN_12B_R)) = DAC_0V;
    121 
    122                         if (cnt++ >= delay_cnt[6])      // 50c
    123                         {
    124                                 cnt = 0;
    125                                 stage = 5;
     570                        if (cnt++ >= delay_cnt[3])
     571                        {
     572                                cnt = 0;
     573                                stage = 0;
    126574                               
    127                                 if (mal++ >= 5/*1600*/)   // approx 95ms
     575                                if (mal++ >= 1600 - 1)    // approx 95ms
    128576                                {
    129577                                        mal = 0;
    130                                         stage = 0;
    131578                                        HAL_NVIC_DisableIRQ(ADC_DMA_IRQ);
    132579                                        if (NULL != ReturnFunctionPtr) MOSFETS_Management = ReturnFunctionPtr;
Note: See TracChangeset for help on using the changeset viewer.