Ignore:
Timestamp:
Aug 4, 2026, 1:53:58 PM (25 hours ago)
Author:
f.jahn
Message:

Delta Sigma ADC auf 10Channel geändert.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r71 r73  
    44#include "esr.h"
    55#include <stdlib.h>
     6#include <stdio.h>
    67#include "main.h"
    7 #include "battery_voltage.h"
     8#include "battery_voltage_fast.h"
    89#include "fast_current.h"
    9 #include "stdio.h"
    1010
     11#define I_MULTIPLIER  ((int64_t) VREF / FAST_CURRENT_SHUNT_RESISTOR /  FAST_CURRENT_I_SENSE_GAIN /  FAST_CURRENT_ADC_RESOLUTION)
     12#define U_MULTIPLIER  ((int64_t) VREF * BATTERY_VOLTAGE_VOLTAGE_DIVIDER / BATTERY_VOLTAGE_FAST_ADC_RESOLUTION )
    1113
    1214int32_t current_buffer[SAMPLE_ARRAY_SIZE]; 
    … …  
    1416
    1517
    16 extern uint32_t adc1Data[SAMPLE_ARRAY_SIZE];
    17 extern uint32_t adc2Data[SAMPLE_ARRAY_SIZE];
    18 extern uint32_t adc4Data[SAMPLE_ARRAY_SIZE];
     18extern int32_t adc1Data[SAMPLE_ARRAY_SIZE];
     19extern int32_t adc2Data[SAMPLE_ARRAY_SIZE];
     20extern int32_t adc4Data[SAMPLE_ARRAY_SIZE];
    1921
    20 
    21 //int16_t ESR_Exec(void)
    22 //{
    23  
    24 
    25 //  static int32_t last_refresh;
    26 //  int x;
    27 
    28 //  //Anzeige vor wieviel Sekunden zuletzt aktualisiert wurd.
    29 //  sys_data.s.values.esrCalcTime = sys_data.s.values.onTime - last_refresh;
    30 
    31 //  for (x=SAMPLE_ARRAY_SIZE-1; x>0; x--)
    32 //  {
    33 //    current_buffer[x] = current_buffer[x-1];
    34 //    voltage_buffer[x] = voltage_buffer[x-1];
    35 //  }
    36 
    37 //  // Neue Werte ins array aufnehmen
    38 //  current_buffer[0] = sys_data.s.values.batteryCurrent;
    39 //  voltage_buffer[0] = sys_data.s.values.batteryVoltage;
    40 
    41 
    42 //  //Suche Min und max werte im Array
    43 //  int32_t minU=INT32_MAX;
    44 //  int32_t maxU=0;
    45 //  int32_t minI=INT32_MAX;
    46 //  int32_t maxI=0;
    47 //  int32_t minIPos = -1;
    48 //  int32_t maxdIPos = -1;
    49 //  int32_t minUPos = -1;
    50 //  int32_t maxUPos = -1;
    51 
    52 //  //Suche min und max werte
    53 //  for (x=0; x < SAMPLE_ARRAY_SIZE; x++)
    54 //  {
    55 //     if (abs(current_buffer[x]) < minI)  { minI = abs(current_buffer[x]); minIPos  = x; }
    56 //     if (abs(current_buffer[x]) >= maxI) { maxI = abs(current_buffer[x]); maxdIPos = x; }
    57 //     if (abs(voltage_buffer[x]) < minU)  { minU = abs(voltage_buffer[x]); minUPos = x; }
    58 //     if (abs(voltage_buffer[x]) > maxU)  { maxU = abs(voltage_buffer[x]); maxUPos = x; }
    59 //  }
    60 
    61  
    62 //  //Suche Zeitpunkt der größten Änderung in I
    63 
    64 //  //Delta berechnen
    65 //  int32_t dI = abs (maxI - minI);
    66 //  int32_t dU = abs (maxU - minU);
    67 
    68 //  //Minimale Belastung Prüfen ob es genügent Änderungen gab
    69 //  // 1/20 des Nennstroms
    70 //  // Bei 100Ah Batterie mit 0,5 Std discharge --> 50A --> /20 =2,5 A
    71 //  int32_t min_dI;
    72 //  min_dI = sys_data.s.parameter.cellCapacity /  sys_data.s.parameter.cellRatedDischargeTime; //Nennlaststrom  in mA
    73 //  min_dI = min_dI / 20 ;
    74 
    75 //  int32_t min_dU = 25;
    76  
    77 //  if( dI < min_dI)
    78 //  {
    79  
    80 //    return -1;
    81 //  }
    82 
    83 //  printf("1)dI change!\r\n");
    84 
    85 //  if (dU < min_dU) {
    86 //    return -2;
    87 //  }
    88 
    89 //  //printf("dU change!\r\n");
    90 
    91  
    92 //  int32_t dIMax=-1;
    93 //  int32_t dIx=-1;;
    94 //  int32_t dIMaxPos=-1;
    95  
    96 //  for (x=0; x < (SAMPLE_ARRAY_SIZE-1); x++)
    97 //  {
    98 //    dIx = abs(current_buffer[x+1] - current_buffer[x]);
    99 //    if (dIx > dIMax) { dIMax = dIx; dIMaxPos = x; }
    100 //  }
    101 
    102 
    103 
    104 //  if (dIMaxPos == SAMPLE_ARRAY_SIZE / 2)
    105 //  {
    106 //    //ESR berechnen!
    107 //    sys_data.s.values.esr = ( (double)dU / (double) dI) * 1000;
    108 //    last_refresh = sys_data.s.values.onTime;
    109 
    110 
    111 //    for (x=0; x < SAMPLE_ARRAY_SIZE; x++)
    112 //    {
    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];
    115 //    }
    116 
    117 
    118    
    119 //  }
    120 //  return 0;
    121 //}
    12222
    12323
    … …  
    12525{
    12626 
    127     printf("esr\r\n");
     27  //  printf("esr\r\n");
    12828  static int32_t last_refresh;
    12929  int x;
    … …  
    13737  //Suche Min und max werte im Array
    13838  int32_t minUBatt=INT32_MAX;
    139   int32_t maxUBatt=0;
     39  int32_t maxUBatt=INT32_MIN;
    14040  int32_t minUOut=INT32_MAX;
    141   int32_t maxUOut=0;
     41  int32_t maxUOut=INT32_MIN;
    14242  int32_t minI=INT32_MAX;
    143   int32_t maxI=0;
     43  int32_t maxI=INT32_MIN;
    14444  int32_t minIPos = -1;
    145   int32_t maxdIPos = -1;
     45  int32_t maxIPos = -1;
    14646  int32_t minUBattPos = -1;
    14747  int32_t maxUBattPos = -1;
    … …  
    14949  int32_t maxUOutPos = -1;
    15050
     51
     52  //Entferne Offset
     53  for (x=0; x < SAMPLE_ARRAY_SIZE -1; x++)
     54  {
     55        adc1Data[x] = adc1Data[x] - FAST_CURRENT_ADC_OFFSET;
     56        adc2Data[x] = adc2Data[x] - BATTERY_VOLTAGE_FAST_ADC_OFFSET;
     57        adc4Data[x] = adc4Data[x] - BATTERY_VOLTAGE_FAST_ADC_OFFSET;
     58  }
     59
     60
     61
    15162  //Suche min und max werte
    15263  for (x=0; x < SAMPLE_ARRAY_SIZE -1; x++)
    15364  {
    154      if (adc1Data[x] < minI)  { minI = adc1Data[x]; minIPos  = x; }
    155      if (adc1Data[x] >= maxI) { maxI = adc1Data[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; }
     65     if (adc1Data[x] <= minI)  { minI = adc1Data[x]; minIPos  = x; }
     66     if (adc1Data[x] >= maxI) { maxI = adc1Data[x]; maxIPos = x; } 
     67     if (adc2Data[x] <= minUBatt)  { minUBatt = adc2Data[x]; minUBattPos = x; }
     68     if (adc2Data[x] >= maxUBatt)  { maxUBatt = adc2Data[x]; maxUBattPos = x; }
     69         if (adc4Data[x] <= minUOut)  { minUOut = adc4Data[x]; minUOutPos = x; }
     70     if (adc4Data[x] >= maxUOut)  { maxUOut = adc4Data[x]; maxUOutPos = x; }
    16071  }
    161 
    162  
    16372
    16473
    16574  //Delta berechnen
    166   int32_t dI = maxI - minI;
    167  
    168   //Nehme nicht mehr die gesamte maximale Differenz der Spannungen, sondern nehme das delt U wo auch das Delta I gemessen wurde
    169   //Funktioniert nur bei Synchroner Messug von Strom und Spannung
    170   //int32_t dU = maxU - minU;
    171   int32_t dUBatt = adc2Data[maxdIPos]  - adc2Data[minIPos];
    172   int32_t dUOut =  adc4Data[maxdIPos]  - adc4Data[minIPos];
     75  int32_t dI;
     76  int32_t dUBatt;
     77  int32_t dUOut;
     78
     79  if (maxIPos > minIPos)
     80  {
     81        dI = maxI - minI;
     82        //Nehme nicht mehr die gesamte maximale Differenz der Spannungen, sondern nehme das delt U wo auch das Delta I gemessen wurde
     83        //Funktioniert nur bei Synchroner Messug von Strom und Spannung
     84        //int32_t dU = maxU - minU;
     85        dUBatt= adc2Data[maxIPos]  - adc2Data[minIPos];
     86        dUOut=  adc4Data[maxIPos]  - adc4Data[minIPos];
     87  }
     88  else
     89  {
     90        dI = minI - maxI;
     91        dUBatt= adc2Data[minIPos]  - adc2Data[maxIPos];
     92        dUOut=  adc4Data[minIPos]  - adc4Data[maxIPos];
     93  }
     94
    17395
    17496  //Umrechnung in mV / mA
    175   dI = dI * ((double) VREF / FAST_CURRENT_SHUNT_RESISTOR /  FAST_CURRENT_I_SENSE_GAIN /  FAST_CURRENT_ADC_RESOLUTION);
    176   dI = dI * (sys_data.s.parameter.batteryCurrentGainCorrectionFaktor / 1000000.0);
    177 
    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 ;
     97  dI = dI * I_MULTIPLIER;
     98  dUBatt = dUBatt  * U_MULTIPLIER;
     99  dUOut  = dUOut  * U_MULTIPLIER;
    180100
    181101  //Minimale Belastung Prüfen ob es genügent Änderungen gab
    … …  
    184104  int32_t min_dI;
    185105  min_dI = sys_data.s.parameter.cellCapacity /  sys_data.s.parameter.cellRatedDischargeTime; //Nennlaststrom  in mA
    186   min_dI = min_dI / 100 ;
     106  min_dI = min_dI / 10 ;
    187107 
    188108
    … …  
    195115  }
    196116
    197   printf("2)dI change!\r\n");
    198117
     118
     119 
     120 int absMax = abs(maxI);
     121 int absMin = abs(minI);
     122
     123 //Suche die Spitze
     124  //if (absMax > absMin){
     125         // //Der größte absolut wert steht in maxI
     126         // //schauen ob die spitze nicht am Anfang oder Ende des arrays ist
     127         // if ((maxIPos < 10) || (maxIPos > 53))
     128         // {
     129                //return -3;
     130         // }
     131         
     132  //}
     133  //else
     134  //{
     135
     136         // if ((minIPos < 10) || (minIPos > 53)) 
     137         // {
     138                //return -3;
     139         // }
     140  //}
    199141  //if (abs(dU) < min_dU) {
    200142  //  return -2;
    … …  
    204146
    205147 
    206   int32_t dIMax=-1;
    207   int32_t dIx=-1;;
    208   int32_t dIMaxPos=-1;
     148//  int32_t dIMax=-1;
     149//  int32_t dIx=-1;;
     150//  int32_t dIMaxPos=-1;
    209151 
    210152
    211153
    212154  //Finde Position der flanke
    213   for (x=0; x < (SAMPLE_ARRAY_SIZE-1); x++)
    214   {
    215     dIx = adc1Data[x+1] - adc1Data[x];
    216     if (dIx > dIMax) { dIMax = dIx; dIMaxPos = x; }
    217   }
     155//  for (x=0; x < (SAMPLE_ARRAY_SIZE-2); x++)
     156//  {
     157//    dIx = adc1Data[x+1] - adc1Data[x];
     158//    if (dIx > dIMax) { dIMax = dIx; dIMaxPos = x; }
     159//  }
    218160
    219  
     161  sys_data.s.values.neg_I_peak = (minI ) * I_MULTIPLIER / 10;
     162  sys_data.s.values.pos_I_peak = (maxI ) * I_MULTIPLIER / 10 ;
     163
     164  sys_data.s.values.neg_U_Batt_peak = (minUBatt ) * U_MULTIPLIER / 10;
     165  sys_data.s.values.pos_U_Batt_peak = (maxUBatt ) * U_MULTIPLIER / 10;
     166  sys_data.s.values.neg_U_Shunt_peak = (minUOut ) * U_MULTIPLIER / 10;
     167  sys_data.s.values.pos_U_Shunt_peak = (maxUOut ) * U_MULTIPLIER / 10;
     168
     169  sys_data.s.values.neg_I_Buffer_pos = minIPos;
     170  sys_data.s.values.pos_I_Buffer_pos = maxIPos;
     171
    220172
    221173
    222174  //ESR berechnen!
    223   sys_data.s.values.esr_fast = ( (double)dUBatt / (double) dI) * 1000;
    224   sys_data.s.values.esr =          ( (double)dUOut  / (double) dI) * 1000;
     175  sys_data.s.values.esr_batt =          ( (double)dUBatt / (double) dI) * 1000;
     176  sys_data.s.values.esr_shunt =     ( (double)dUOut  / (double) dI) * 1000;
    225177  last_refresh = sys_data.s.values.onTime;
    226178       
    … …  
    228180  for (x=0; x < SAMPLE_ARRAY_SIZE; x++)
    229181  {
    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 ;
     182        sys_data.s.values.current_buffer[x] =            adc1Data[x]  ;
     183        sys_data.s.values.voltage_buffer_batt[x] =       adc2Data[x] ;
     184        sys_data.s.values.voltage_buffer_shunt[x] =  adc4Data[x]  ;
    232185  }
    233186
    234187
     188  //Auswertung darf nur erfolgen wenn Singulares Erreigniss nicht am Anfang oder Ende des Buffers erfolgt.
     189  //Also z.B. bei der Belastung mit elektronischer Last. Da ansonsten eventuell nicht der Beginn der Kurve mit aufgezeichnet wird
     190  //printf("delta I: %d, deltaUBatt=%d, deltaUOut=%d,posMax=%d; posMin=%d, esr1=%d, esr2=%d \r\n",dI,dUBatt,dUOut,maxIPos, minIPos,sys_data.s.values.esr_batt,sys_data.s.values.esr_shunt);
    235191
    236192
Note: See TracChangeset for help on using the changeset viewer.