Ignore:
Timestamp:
Apr 1, 2026, 9:33:58 AM (5 weeks ago)
Author:
f.jahn
Message:

Fixing Projects.

Location:
trunk/fw_g473rct/SES/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/fw_g473rct/SES/src/esr.c

    r38 r55  
    1414
    1515
    16 extern uint16_t adc12Data[SAMPLE_ARRAY_SIZE][2];
     16extern uint16_t adc1Data[SAMPLE_ARRAY_SIZE];
     17extern uint16_t adc2Data[SAMPLE_ARRAY_SIZE];
     18extern uint16_t adc4Data[SAMPLE_ARRAY_SIZE];
    1719
    1820
    … …  
    109111    for (x=0; x < SAMPLE_ARRAY_SIZE; x++)
    110112    {
    111       sys_data.s.values.current_buffer[(SAMPLE_ARRAY_SIZE-1)-x] = adc12Data[x][0];
    112       sys_data.s.values.voltage_buffer[(SAMPLE_ARRAY_SIZE-1)-x] = adc12Data[x][1];
     113      sys_data.s.values.current_buffer[(SAMPLE_ARRAY_SIZE-1)-x] = adc1Data[x];
     114      sys_data.s.values.voltage_buffer[(SAMPLE_ARRAY_SIZE-1)-x] = adc2Data[x];
    113115    }
    114116
    … …  
    134136
    135137  //Suche Min und max werte im Array
    136   int32_t minU=INT32_MAX;
    137   int32_t maxU=0;
     138  int32_t minUBatt=INT32_MAX;
     139  int32_t maxUBatt=0;
     140  int32_t minUOut=INT32_MAX;
     141  int32_t maxUOut=0;
    138142  int32_t minI=INT32_MAX;
    139143  int32_t maxI=0;
    140144  int32_t minIPos = -1;
    141145  int32_t maxdIPos = -1;
    142   int32_t minUPos = -1;
    143   int32_t maxUPos = -1;
     146  int32_t minUBattPos = -1;
     147  int32_t maxUBattPos = -1;
     148  int32_t minUOutPos = -1;
     149  int32_t maxUOutPos = -1;
    144150
    145151  //Suche min und max werte
    146152  for (x=0; x < SAMPLE_ARRAY_SIZE; x++)
    147153  {
    148      if (adc12Data[x][0] < minI)  { minI = adc12Data[x][0]; minIPos  = x; }
    149      if (adc12Data[x][0] >= maxI) { maxI = adc12Data[x][0]; maxdIPos = x; } 
    150      if (adc12Data[x][1] < minU)  { minU = adc12Data[x][1]; minUPos = x; }
    151      if (adc12Data[x][1] > maxU)  { maxU = adc12Data[x][1]; maxUPos = x; }
     154     if (adc1Data[x] < minI)  { minI = adc1Data[x]; minIPos  = x; }
     155     if (adc1Data[x] >= maxI) { maxI = adc2Data[x]; maxdIPos = x; } 
     156     if (adc2Data[x] < minUBatt)  { minUBatt = adc2Data[x]; minUBattPos = x; }
     157     if (adc2Data[x] > maxUBatt)  { maxUBatt = adc2Data[x]; maxUBattPos = x; }
     158         if (adc4Data[x] < minUOut)  { minUOut = adc4Data[x]; minUOutPos = x; }
     159     if (adc4Data[x] > maxUOut)  { maxUOut = adc4Data[x]; maxUOutPos = x; }
    152160  }
    153161
    … …  
    161169  //Funktioniert nur bei Synchroner Messug von Strom und Spannung
    162170  //int32_t dU = maxU - minU;
    163   int32_t dU = adc12Data[maxdIPos][1]  - adc12Data[minIPos][1];
     171  int32_t dUBatt = adc2Data[maxdIPos]  - adc2Data[minIPos];
     172  int32_t dUOut =  adc4Data[maxdIPos]  - adc4Data[minIPos];
    164173
    165174  //Umrechnung in mV / mA
    … …  
    167176  dI = dI * (sys_data.s.parameter.batteryCurrentGainCorrectionFaktor / 1000000.0);
    168177
    169   dU = dU  * (double )VREF * BATTERY_VOLTAGE_VOLTAGE_DIVIDER / BATTERY_VOLTAGE_ADC_RESOLUTION ;
    170  
     178  dUBatt = dUBatt  * (double )VREF * BATTERY_VOLTAGE_VOLTAGE_DIVIDER / BATTERY_VOLTAGE_ADC_RESOLUTION ;
     179  dUOut  = dUOut  * (double )VREF * BATTERY_VOLTAGE_VOLTAGE_DIVIDER / BATTERY_VOLTAGE_ADC_RESOLUTION ;
    171180
    172181  //Minimale Belastung Prüfen ob es genügent Änderungen gab
    … …  
    188197  //printf("dI change!\r\n");
    189198
    190   if (abs(dU) < min_dU) {
    191     return -2;
    192   }
     199  //if (abs(dU) < min_dU) {
     200  //  return -2;
     201  //}
    193202
    194203  //printf("dU change!\r\n");
    … …  
    204213  for (x=0; x < (SAMPLE_ARRAY_SIZE-1); x++)
    205214  {
    206     dIx = adc12Data[x+1][0] - adc12Data[x][0];
     215    dIx = adc1Data[x+1] - adc1Data[x];
    207216    if (dIx > dIMax) { dIMax = dIx; dIMaxPos = x; }
    208217  }
    209218
    210   //if ((dIMaxPos < 5 ) || (dIMaxPos > (SAMPLE_ARRAY_SIZE-5) ))
    211   //{
    212 //      return -3;
    213  // }
     219 
    214220
    215221
    216222  //ESR berechnen!
    217   sys_data.s.values.esr_fast = ( (double)dU / (double) dI) * 10000;
     223  sys_data.s.values.esr_fast = ( (double)dUBatt / (double) dI) * 10000;
     224  sys_data.s.values.esr =          ( (double)dUOut  / (double) dI) * 10000;
    218225  last_refresh = sys_data.s.values.onTime;
    219226       
    … …  
    221228  for (x=0; x < SAMPLE_ARRAY_SIZE; x++)
    222229  {
    223         sys_data.s.values.current_buffer_fast[x] = (int32_t) adc12Data[x][0] - FAST_CURRENT_ADC_OFFSET  ;
    224         sys_data.s.values.voltage_buffer_fast[x] = (int32_t) adc12Data[x][1] - BATTERY_VOLTAGE_ADC_OFFSET ;
     230        sys_data.s.values.current_buffer_fast[x] = (int32_t) adc1Data[x] - FAST_CURRENT_ADC_OFFSET  ;
     231        sys_data.s.values.voltage_buffer_fast[x] = (int32_t) adc2Data[x] - BATTERY_VOLTAGE_ADC_OFFSET ;
    225232  }
    226233

  • trunk/fw_g473rct/SES/src/main.c

    r25 r55  
    265265    {
    266266      ADS1260_ConversionFinished();
    267       ESR_Exec();
    268 
    269267      newCurrentValue = 0;
    270268

  • trunk/fw_g473rct/SES/src/outputs.c

    r38 r55  
    4545}
    4646
     47
     48
     49void OUTPUTS_OverwriteChargeCtrl_ChargeEnabled(void)
     50{
     51  GPIO_InitTypeDef GPIO_InitStruct = {0};
     52  GPIO_InitStruct.Pin = OVERWRITE_CHARGE_CTRL_Pin;
     53  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
     54  GPIO_InitStruct.Pull = GPIO_NOPULL;
     55  HAL_GPIO_Init(OVERWRITE_CHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
     56  HAL_GPIO_WritePin(OVERWRITE_CHARGE_CTRL_GPIO_Port, OVERWRITE_CHARGE_CTRL_Pin, OUTPUTS_CHARGE_ALLOWED);
     57
     58
     59}
     60
     61
     62void OUTPUTS_OverwriteChargeCtrl_ChargeDisabled(void)
     63{
     64  GPIO_InitTypeDef GPIO_InitStruct = {0};
     65  GPIO_InitStruct.Pin = OVERWRITE_CHARGE_CTRL_Pin;
     66  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
     67  GPIO_InitStruct.Pull = GPIO_NOPULL;
     68  HAL_GPIO_Init(OVERWRITE_CHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
     69
     70  HAL_GPIO_WritePin(OVERWRITE_CHARGE_CTRL_GPIO_Port, OVERWRITE_CHARGE_CTRL_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     71
     72
     73}
     74
     75
     76void OUTPUTS_OverwriteChargeCtrl_Disabled(void)
     77{
     78  GPIO_InitTypeDef GPIO_InitStruct = {0};
     79  GPIO_InitStruct.Pin = OVERWRITE_CHARGE_CTRL_Pin;
     80  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
     81  GPIO_InitStruct.Pull = GPIO_NOPULL;
     82  HAL_GPIO_Init(OVERWRITE_CHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
     83
     84
     85}
     86
     87
     88void OUTPUTS_OverwriteDischargeCtrl_DischargeEnabled(void)
     89{
     90  GPIO_InitTypeDef GPIO_InitStruct = {0};
     91  GPIO_InitStruct.Pin = OVERWRITE_DISCHARGE_CTRL_Pin;
     92  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
     93  GPIO_InitStruct.Pull = GPIO_NOPULL;
     94  HAL_GPIO_Init(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
     95  HAL_GPIO_WritePin(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, OVERWRITE_DISCHARGE_CTRL_Pin, OUTPUTS_DISCHARGE_ALLOWED);
     96
     97
     98}
     99
     100
     101void OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled(void)
     102{
     103  GPIO_InitTypeDef GPIO_InitStruct = {0};
     104  GPIO_InitStruct.Pin = OVERWRITE_DISCHARGE_CTRL_Pin;
     105  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
     106  GPIO_InitStruct.Pull = GPIO_NOPULL;
     107  HAL_GPIO_Init(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
     108
     109  HAL_GPIO_WritePin(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, OVERWRITE_DISCHARGE_CTRL_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     110
     111
     112}
     113
     114
     115void OUTPUTS_OverwriteDischargeCtrl_Disabled(void)
     116{
     117  GPIO_InitTypeDef GPIO_InitStruct = {0};
     118  GPIO_InitStruct.Pin = OVERWRITE_DISCHARGE_CTRL_Pin;
     119  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
     120  GPIO_InitStruct.Pull = GPIO_NOPULL;
     121  HAL_GPIO_Init(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
     122
     123
     124}
     125
    47126/*
    48127* @brief        Prüfen ob LVP Signal abgeschaltet werden muss
    … …  
    69148                                printf("OUTPUTS_LVP_BATTERY_UNDERVOLTAGE\n");
    70149                                sys_data.s.values.lvpState = OUTPUTS_LVP_BATTERY_UNDERVOLTAGE;
    71                                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_NOT_ALLOWED);
     150                                OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
    72151                        }
    73152                        else if(sys_data.s.values.batteryCurrent < ((int32_t)sys_data.s.parameter.loadCurrentLimit*1000))
    … …  
    75154                                printf("OUTPUTS_LVP_OVERCURRENT\n");
    76155                                sys_data.s.values.lvpState = OUTPUTS_LVP_OVERCURRENT;
    77                                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_NOT_ALLOWED);
     156                                OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
    78157                        }
    79158                        else if(sys_data.s.values.shuntTemperature > sys_data.s.parameter.dischargeStopHighTemperatureStart)
    … …  
    81160                                printf("OUTPUTS_LVP_SHUNT_OVERTEMPERATURE\n");
    82161                                sys_data.s.values.lvpState = OUTPUTS_LVP_SHUNT_OVERTEMPERATURE;
    83                                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_NOT_ALLOWED);
     162                                OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
    84163                        }
    85164                        else if(sys_data.s.values.chipTemperature > sys_data.s.parameter.dischargeStopHighTemperatureStart)
    … …  
    87166                                printf("OUTPUTS_LVP_CHIP_OVERTEMPERATURE\n");
    88167                                sys_data.s.values.lvpState = OUTPUTS_LVP_CHIP_OVERTEMPERATURE;
    89                                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_NOT_ALLOWED);
     168                                OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
    90169                        }
    91170                        else if(sys_data.s.values.shuntTemperature < sys_data.s.parameter.dischargeStopLowTemperatureStart)
    … …  
    93172                                printf("OUTPUTS_LVP_SHUNT_UNDERTEMPERATURE\n");
    94173                                sys_data.s.values.lvpState = OUTPUTS_LVP_SHUNT_UNDERTEMPERATURE;
    95                                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_NOT_ALLOWED);
     174                                OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
    96175                        }
    97176                        else if(sys_data.s.values.chipTemperature < sys_data.s.parameter.dischargeStopLowTemperatureStart)
    … …  
    99178                                printf("OUTPUTS_LVP_CHIP_OVERTEMPERATURE\n");
    100179                                sys_data.s.values.lvpState = OUTPUTS_LVP_CHIP_UNDERTEMPERATURE;
    101                                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_NOT_ALLOWED);
     180                                OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
    102181                        }
    103182                }
    … …  
    123202                                printf("OUTPUT LVP OK\n");
    124203                                sys_data.s.values.lvpState = OUTPUTS_LVP_OK;
    125                                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_ALLOWED);
     204                                OUTPUTS_OverwriteDischargeCtrl_Disabled();
    126205                        }
    127206                }
    … …  
    129208        else if (sys_data.s.parameter.lvpMode == OUTPUTS_LVP_MODE_MANUAL_ON)
    130209        {
    131                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_ALLOWED);
     210                OUTPUTS_OverwriteDischargeCtrl_DischargeEnabled();
    132211        }
    133212        else if (sys_data.s.parameter.lvpMode == OUTPUTS_LVP_MODE_MANUAL_OFF)
    134213        {
    135                 HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_NOT_ALLOWED);
    136         }
    137         else HAL_GPIO_WritePin(DISCHARGE_ENABLE_GPIO_Port, DISCHARGE_ENABLE_Pin, OUTPUTS_DISCHARGE_NOT_ALLOWED);
     214                OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
     215        }
     216        else
     217        {
     218                OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
     219        }
    138220
    139221        lastMode = sys_data.s.parameter.lvpMode;
    … …  
    164246                                printf("OUTPUTS_OVP_BATTERY_OVERVOLTAGE\n");
    165247                                sys_data.s.values.ovpState = OUTPUTS_OVP_BATTERY_OVERVOLTAGE;
    166                                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     248                                OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
    167249                        }
    168250                        else if(sys_data.s.values.batteryCurrent > ((int32_t) sys_data.s.parameter.chargeCurrentLimit * 1000))
    … …  
    170252                                printf("OUTPUTS_OVP_OVERCURRENT\n");
    171253                                sys_data.s.values.ovpState = OUTPUTS_OVP_OVERCURRENT;
    172                                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     254                                OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
    173255                        }
    174256                        else if(sys_data.s.values.shuntTemperature > sys_data.s.parameter.chargeStopHighTemperatureStart)
    … …  
    176258                                printf("OUTPUTS_OVP_SHUNT_OVERTEMPERATURE\n");
    177259                                sys_data.s.values.ovpState = OUTPUTS_OVP_SHUNT_OVERTEMPERATURE;
    178                                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     260                                OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
    179261                        }
    180262                        else if(sys_data.s.values.chipTemperature > sys_data.s.parameter.chargeStopHighTemperatureStart)
    … …  
    182264                                printf("OUTPUTS_OVP_CHIP_OVERTEMPERATURE\n");
    183265                                sys_data.s.values.ovpState = OUTPUTS_OVP_CHIP_OVERTEMPERATURE;
    184                                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     266                                OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
    185267                        }
    186268                        else if(sys_data.s.values.shuntTemperature < sys_data.s.parameter.chargeStopLowTemperatureStart)
    … …  
    188270                                printf("OUTPUTS_OVP_SHUNT_UNDERTEMPERATURE\n");
    189271                                sys_data.s.values.ovpState = OUTPUTS_OVP_SHUNT_UNDERTEMPERATURE;
    190                                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     272                                OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
    191273                        }
    192274                        else if(sys_data.s.values.chipTemperature < sys_data.s.parameter.chargeStopLowTemperatureStart)
    … …  
    194276                                printf("OUTPUTS_OVP_CHIP_UNDETEMPERATURE\n");
    195277                                sys_data.s.values.ovpState = OUTPUTS_OVP_CHIP_UNDERTEMPERATURE;
    196                                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     278                                OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
    197279                        }
    198280                }
    … …  
    213295                                printf("OUTPUT OVP OK\n");
    214296                                sys_data.s.values.ovpState = OUTPUTS_OVP_OK;
    215                                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_ALLOWED);
     297                                OUTPUTS_OverwriteChargeCtrl_Disabled(); // externer steuerung
    216298                        }
    217299                }
    … …  
    219301        else if (sys_data.s.parameter.ovpMode == OUTPUTS_OVP_MODE_MANUAL_ON)
    220302        {
    221                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_ALLOWED);
     303                OUTPUTS_OverwriteChargeCtrl_ChargeEnabled(); //ACHTUNG: Manual On
    222304        }
    223305        else if (sys_data.s.parameter.ovpMode == OUTPUTS_OVP_MODE_MANUAL_OFF)
    224306        {
    225                 HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
    226         }
    227         else HAL_GPIO_WritePin(CHARGE_ENABLE_GPIO_Port, CHARGE_ENABLE_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
     307                OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
     308        }
     309        else
     310        {
     311          OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
     312        }
    228313
    229314        lastMode = sys_data.s.parameter.ovpMode;
Note: See TracChangeset for help on using the changeset viewer.