Changeset 24 for trunk/fw_g473rct/SES


Ignore:
Timestamp:
Aug 31, 2025, 6:56:29 PM (5 days ago)
Author:
f.jahn
Message:

Shunt Temperatursensor aktiviert

Location:
trunk/fw_g473rct/SES
Files:
9 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/fw_g473rct/SES/inc/fast_current.h

    r20 r24  
    2020
    2121//--- GLOBALE FUNKTIONS PROTOTYPEN ---------------------------------------------
    22 void FAST_CURRENT_Exec(uint32_t newvalP, uint32_t newvalM );
     22void FAST_CURRENT_Exec(uint32_t newVal );
    2323
    2424#endif //

  • trunk/fw_g473rct/SES/inc/int_bat_voltage.h

    r23 r24  
    2626* @retval       kein
    2727*/
    28 void REF_VOLTAGE_Exec(uint32_t newval);
     28void INT_BAT_VOLTAGE_Exec(uint32_t newval);
    2929
    3030#endif // __REF_VOLTAGE_H

  • trunk/fw_g473rct/SES/smartPro.emProject

    r22 r24  
    185185      <file file_name="inc/esr.h" />
    186186      <file file_name="inc/fast_current.h" />
     187      <file file_name="inc/int_bat_voltage.h" />
    187188      <file file_name="inc/modbus.h" />
    188189      <file file_name="inc/outputs.h" />
    189       <file file_name="inc/ref_voltage.h" />
    190190      <file file_name="inc/rtc.h" />
    191191      <file file_name="inc/self_discharge.h" />
    … …  
    212212      <file file_name="src/esr.c" />
    213213      <file file_name="src/fast_current.c" />
     214      <file file_name="src/int_bat_voltage.c" />
    214215      <file file_name="src/main.c" />
    215216      <file file_name="src/modbus.c" />
    216217      <file file_name="src/outputs.c" />
    217       <file file_name="src/ref_voltage.c" />
    218218      <file file_name="src/self_discharge.c" />
    219219      <file file_name="src/shunt_temperature.c" />

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

    r22 r24  
    1313#include "main.h"
    1414#include "sysdata.h"
    15 
     15#include <stdio.h>
    1616//      --- EXTERNE VARIABLEN --------------------------------------------------------
    1717
    1818//      --- LOKALE DEFINES - bitte hier dokumentieren --------------------------------
    19 #define BATTERY_VOLTAGE_FILTER  256
     19#define BATTERY_VOLTAGE_FILTER  32
    2020
    2121
    22 #define BATTERY_VOLTAGE_VOLTAGE_DIVIDER       6
    23 #define ADC_RESOLUTION                                            65536 //65536/2 da im differential mode
    24 #define ADC_OFFSET                                                        0
    25 #define VREF                                                              3000
     22#define BATTERY_VOLTAGE_VOLTAGE_DIVIDER       6.0
     23#define ADC_RESOLUTION                                            32768.0 //65536/2 da im differential mode
     24#define ADC_OFFSET                                                        32768.0
     25
    2626//      --- LOKALE TYPE DEFS - bitte hier dokumentieren-------------------------------
    2727
    … …  
    3737
    3838
    39 void BATTERY_VOLTAGE_Exec(int32_t newvalP )
     39void BATTERY_VOLTAGE_Exec(int32_t newVal)
    4040{
    4141  static int measCounter;
    42   static unsigned long avgsumP = 0;
    43   int32_t avgvalP;
    44 
     42  static unsigned long avgSum = 0;
     43  int32_t avgVal;
    4544  if (measCounter < INT32_MAX) measCounter++;
    4645
    4746
    4847  // Filterlängen in 2er-Potenzen --> Compiler optimiert
    49   avgsumP -= avgsumP / BATTERY_VOLTAGE_FILTER;
    50   avgsumP += newvalP;
    51   avgvalP = avgsumP / BATTERY_VOLTAGE_FILTER;
     48  avgSum -= avgSum / BATTERY_VOLTAGE_FILTER;
     49  avgSum += newVal;
     50  avgVal =  avgSum / BATTERY_VOLTAGE_FILTER;
    5251
    5352 
    … …  
    5554
    5655  //Umrechung auf Eingangsspannung am Gerät mit Teiler
    57   sys_data.s.values.batteryVoltage = ((avgvalP-2048) * 3000 * BATTERY_VOLTAGE_VOLTAGE_DIVIDER ) / 2048;
     56  sys_data.s.values.batteryVoltage = ((avgVal-ADC_OFFSET) * VREF * BATTERY_VOLTAGE_VOLTAGE_DIVIDER ) / ADC_RESOLUTION;
    5857
    5958 
    … …  
    7574
    7675
    77   //Berechnung schnellen Wert ohne Glättung:
     76  //Berechnung schnelle Wert ohne Glättung:
    7877  //Umrechung auf Eingangsspannung am Gerät mit Teiler
    79   sys_data.s.values.fast_voltage = ((newvalP-ADC_OFFSET) * VREF * BATTERY_VOLTAGE_VOLTAGE_DIVIDER ) / ADC_RESOLUTION;
     78  sys_data.s.values.fast_voltage = ((newVal-ADC_OFFSET) * VREF * BATTERY_VOLTAGE_VOLTAGE_DIVIDER ) / ADC_RESOLUTION;
    8079
    8180

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

    r20 r24  
    2424//      --- LOKALE VARIABLEN - bitte hier dokumentieren ------------------------------
    2525uint32_t calTemperatureSensor30Value;  // Kalibrierungswert für den Temperatursensor auf dem STM32G0 (Werksmäßig im SCB Bereich gespeichert wird beim Programmstart ausgelesen)
    26 uint32_t calTemperatureSensor130Value; // Kalibrierungswert für den Temperatursensor auf dem STM32G0 (Werksmäßig im SCB Bereich gespeichert wird beim Programmstart ausgelesen)
     26uint32_t calTemperatureSensor110Value; // Kalibrierungswert für den Temperatursensor auf dem STM32G0 (Werksmäßig im SCB Bereich gespeichert wird beim Programmstart ausgelesen)
    2727uint32_t calTemperatureSensorDiff;     // Differenz calTemperatureSensor130Value und calTemperatureSensor30Value wird für die Kalibrierung des internen Temperatursensors bentigt
    2828                                                              // Daten Temperaturanzeige µProzessor
    29 
     29double slope;
    3030//      --- LOKALE FUNKTIONS PROTOTYPEN ----------------------------------------------
    3131
    … …  
    4646  uint16_t * pCalibrationData;
    4747  float calibrationData30;
    48   float calibrationData130;
     48  float calibrationData110;
    4949
    5050  // lade Temperatur Kalibrierungswert (Wert bei 30°C)
    … …  
    5555  //Berechnung Spannung in mV bei CAL Punk 30°C
    5656  //Kalbibrierung wurde mit 12 Bit und 3000mV Vref durchgeführt
    57   calibrationData30 = calibrationData30 / 4096;
    58   calTemperatureSensor30Value = calibrationData30 * 3000 ;      // jetzt haben wir die Kalibrierungsspannung in Volt bei 30°C;
     57  calTemperatureSensor30Value = (calibrationData30 * 3000) / 4096 ;      // jetzt haben wir die Kalibrierungsspannung in Volt bei 30°C;
    5958
    6059  pCalibrationData = (uint16_t *)TEMPSENSOR_CAL2_ADDR;
    61   calibrationData130  = * pCalibrationData;
     60  calibrationData110  = * pCalibrationData;
    6261
    63   //Berechnung Spannung in mV bei CAL Punk 130°C
     62  //Berechnung Spannung in mV bei CAL Punk 110°C
    6463  //Kalbibrierung wurde mit 12 Bit und 3000mV Vref durchgeführt
    65   calibrationData130 = calibrationData130 / 4096;
    66   calTemperatureSensor130Value = calibrationData130 * 3000;      // jetzt haben wir die Kalibrierungsspannung in Volt bei 130°C;
     64  calTemperatureSensor110Value = (calibrationData110 * 3000 / 4096);      // jetzt haben wir die Kalibrierungsspannung in Volt bei 110°C;
    6765
    6866  // Spannungsdifferenz bei 100 Kelvin Temperatureunterschied
    69   calTemperatureSensorDiff = (calTemperatureSensor130Value - calTemperatureSensor30Value);
     67  // Slope enthält die Änderung in mV pro °C
     68  calTemperatureSensorDiff = (calTemperatureSensor110Value - calTemperatureSensor30Value);
     69  slope = (double) calTemperatureSensorDiff / (TEMPSENSOR_CAL2_TEMP - TEMPSENSOR_CAL1_TEMP);
     70
     71
    7072}
    7173
    7274void CHIP_TEMPERATURE_Exec(uint32_t chiptemperature)
    7375{
    74     int32_t voltage;
     76    double voltage;
    7577    //Aktuelle Spannung am Temp Sensor
    76     voltage = (3300 * chiptemperature) / 65536;
     78    voltage = (3000 * chiptemperature) / 65536;
    7779
    7880
    7981    voltage = voltage - calTemperatureSensor30Value;
    80     voltage = voltage * 100000; //100000 da Kalibrierwerte 100 Kelvin Delta T haben und wir alles in m°C rechnen
    81     voltage = voltage / (int32_t)(calTemperatureSensorDiff);
    82     voltage = voltage + 30000; //30000 da Erste Kalibrierpunkt bei 30°C --> 30 000 m°C
     82    voltage = voltage  / slope;
     83    voltage = voltage + 30.0;
    8384
    84     //Durch 10 teilen, damit es in 16 Bit signed modbus register passt
    85     sys_data.s.values.chipTemperature = voltage /10 ;
     85        //*100 für Kommastellen
     86    sys_data.s.values.chipTemperature = voltage * 100 ;
    8687
    8788        calc_temp_compensation();

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

    r20 r24  
    1717
    1818//      --- LOKALE DEFINES - bitte hier dokumentieren --------------------------------
    19 //#define FAST_CURRENT_FILTER  2
    20 
    21 
    2219
    2320#define I_SENSE_GAIN    40.0
     21#define ADC_OFFSET                                                        32768
     22#define ADC_RESOLUTION                                            32768 //65536/2 da im differential mode
    2423
    2524
    … …  
    5150
    5251
    53 void FAST_CURRENT_Exec(uint32_t newvalP, uint32_t newvalM )
     52void FAST_CURRENT_Exec(uint32_t newVal )
    5453{
    55   static int measCounter;
    56   static unsigned long avgsumP = 0;
    57   uint32_t avgvalP;
    58 
    59   if (measCounter < INT32_MAX) measCounter++;
    60 
    61 
    62   // Filterlängen in 2er-Potenzen --> Compiler optimiert
    63  // avgsumP -= avgsumP / FAST_CURRENT_FILTER;
    64  // avgsumP += newvalP;
    65 //  avgvalP = avgsumP / FAST_CURRENT_FILTER;
    66 
    67 //  static unsigned long avgsumM = 0;
    68 //  uint32_t avgvalM;
    69   // Filterlängen in 2er-Potenzen --> Compiler optimiert
    70 //  avgsumM -= avgsumM / FAST_CURRENT_FILTER;
    71 //  avgsumM += newvalM;
    72 //  avgvalM = avgsumM / FAST_CURRENT_FILTER;
    73 
    74 
    75   //Berechne Differenzspannung am ADC Eingnag
    76   double diff;
    77   diff = (int32_t) newvalP - (int32_t) newvalM;
    78   diff = (diff * sys_data.s.values.realVdd)  / 65536;
    79 
     54 
    8055  //Umrechung auf Strom
    8156  double temp_current;
    82   temp_current = (diff / I_SENSE_GAIN) /  SHUNT_RESISTOR;
     57  temp_current = ((int32_t) newVal - ADC_OFFSET) * VREF ;
     58  temp_current = temp_current / ADC_RESOLUTION;
     59  temp_current = temp_current / I_SENSE_GAIN ;
     60  temp_current = temp_current / SHUNT_RESISTOR ;
    8361  sys_data.s.values.fast_current = temp_current * (sys_data.s.parameter.batteryCurrentGainCorrectionFaktor / 1000000.0);
    8462 

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

    r23 r24  
    1212#include "main.h"
    1313#include "sysdata.h"
     14#include "int_bat_voltage.h"
    1415//      --- EXTERNE VARIABLEN --------------------------------------------------------
    1516
    … …  
    3435
    3536//      --- GLOBALE FUNKTIONEN - bitte in Header dokumentieren------------------------
    36 void REF_VOLTAGE_Exec(uint32_t newval)
     37void INT_BAT_VOLTAGE_Exec(uint32_t newval)
    3738{
    38    static unsigned long avgsum = 0;
    39    uint32_t avgval;
    40    // Filterlängen in 2er-Potenzen --> Compiler optimiert
    41    avgsum -= avgsum / REF_FILTER;
    42    avgsum += newval;
    43    avgval = avgsum / REF_FILTER;
    44 
    4539  // Messung Externe Spannung basierend auf 3,3V Versorgungsspannung
    4640  // Nur für Debug Zwecke
    47   sys_data.s.values.voltageVref =  (avgval * 3300) / 65536;
     41  sys_data.s.values.voltageVref = VREF;
    4842 
    49   // Ermittlung Vdd als Referenz
    50   sys_data.s.values.realVdd =  3000L * 65536 / avgval;;
     43 
     44  sys_data.s.values.realVdd =  3 * (newval * VREF) / 65536;
    5145}
    5246/*************************** End of file ****************************/

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

    r23 r24  
    3939#include "battery_voltage.h"
    4040#include "ads1260.h"
     41#include "shunt_voltage.h"
     42#include "fast_current.h"
     43#include "int_bat_voltage.h"
     44#include "chip_temperature.h"
     45#include "shunt_temperature.h"
    4146/* USER CODE END Includes */
    4247
    … …  
    6166modbus_t modbusData __attribute__((section(".RAM1")));
    6267
    63 __IO uint16_t adc12Data[2] __attribute__((section(".RAM1")));
     68__IO uint16_t adc12Data[100][2] __attribute__((section(".RAM1")));
    6469__IO uint32_t adc1Data[1] __attribute__((section(".RAM1")));
    6570__IO uint32_t adc2Data[1] __attribute__((section(".RAM1")));
    … …  
    6873__IO uint32_t adc5Data[4] __attribute__((section(".RAM1")));
    6974int silentmode =0;
    70 static volatile uint32_t newADC1Data = 0;
    71 static volatile uint32_t newADC2Data = 0;
     75static volatile uint32_t newADC12Data = 0;
     76static volatile uint32_t newADC3Data = 0;
     77static volatile uint32_t newADC4Data = 0;
     78static volatile uint32_t newADC5Data = 0;
    7279/* USER CODE END PV */
    7380
    … …  
    95102    uint8_t firstStartCatcher;
    96103        int mode_button_disable_time=0;
     104        uint32_t adc12_time;
     105        uint32_t adc12_lasttime;
    97106  /* USER CODE END 1 */
    98107
    … …  
    160169
    161170    // STM32G0 Chiptemperatur Kalibrierung
    162   CHIP_TEMPERATURE_Calibration(/*&sys_data*/);
     171  CHIP_TEMPERATURE_Calibration();
    163172
    164173  HAL_ADCEx_Calibration_Start(&hadc1, ADC_DIFFERENTIAL_ENDED);
    … …  
    169178
    170179
    171 
    172180  //SET_BIT(hadc2.Instance->CFGR, ADC_CFGR_DMAEN); //Enable DMA transfer for ADC slave (ADC12_CCR.MDMA = 0b00 -> MDMA mode disabled)
    173181  //HAL_DMA_Start(hadc2.DMA_Handle,(uint32_t)&hadc2.Instance->DR, (uint32_t)adc2Data,1); //Start ADC slave DMA
    … …  
    175183 
    176184    //HAL_ADC_Start_DMA(&hadc2, (uint32_t*)adc2Data, 1);
    177   if (HAL_ADCEx_MultiModeStart_DMA(&hadc1,(uint32_t *)adc12Data,1))  //Start ADC interleaved mode
     185  if (HAL_ADCEx_MultiModeStart_DMA(&hadc1,(uint32_t *)adc12Data,100))  //Start ADC interleaved mode
    178186  {
    179187     /* Start Error */
    180188     Error_Handler();
    181189  }
     190
     191  if (HAL_ADC_Start_DMA(&hadc3, (uint32_t *) adc3Data , 3))
     192  {
     193     /* Start Error */
     194     Error_Handler();
     195  }
     196
     197  if (HAL_ADC_Start_DMA(&hadc4, (uint32_t *) adc4Data , 1))
     198  {
     199     /* Start Error */
     200     Error_Handler();
     201  }
     202
    182203
    183204  if (HAL_ADC_Start_DMA(&hadc5, (uint32_t *) adc5Data , 4))
    … …  
    196217
    197218    /* USER CODE BEGIN 3 */
    198         if (newADC1Data == 1)
    199     {
    200           BATTERY_VOLTAGE_Exec( adc12Data[1]);
    201         }
    202 
     219        if (newADC12Data == 1)
     220    {
     221          //Mit ADC_DIV2,Sample time 12,5Cycklen, ADC Clock 50Mhz, Oversampling 256
     222          //Tconv = 6400 Takte = 0,128ms Pro Konvertierung. Also für 100 messwerte 12,8mS
     223          BATTERY_VOLTAGE_Exec( adc12Data[0][1]);
     224          FAST_CURRENT_Exec(adc12Data[0][0]);
     225          newADC12Data = 0;
     226          adc12_time = HAL_GetTick() - adc12_lasttime;
     227          adc12_lasttime = HAL_GetTick();
     228
     229        }
     230
     231
     232        if (newADC3Data == 1)
     233    {
     234          SHUNT_TEMPERATURE_Exec(adc3Data[0]);
     235        }
     236
     237
     238        if (newADC4Data == 1)
     239    {
     240          SHUNT_VOLTAGE_Exec( adc4Data[0]);
     241        }
     242
     243
     244        if (newADC5Data == 1)
     245    {
     246          CHIP_TEMPERATURE_Exec(adc5Data[0]);
     247          INT_BAT_VOLTAGE_Exec( adc5Data[1]);
     248          sys_data.s.values.ovp_sense =  (adc5Data[2] * VREF * 21 ) / 65536.0;
     249      sys_data.s.values.lvp_sense =  (adc5Data[3] * VREF * 21 ) / 65536.0;
     250        }
    203251
    204252        if(sys_data.s.parameter.command != 0)
    … …  
    327375    if (hadc->Instance==ADC1)
    328376        {
    329           newADC1Data=1;
    330         }
    331 
    332         if (hadc->Instance==ADC2)
     377          newADC12Data=1;
     378        }
     379
     380        if (hadc->Instance==ADC3)
    333381        {
    334           newADC2Data=1;
     382          newADC3Data=1;
     383        }
     384
     385
     386        if (hadc->Instance==ADC4)
     387        {
     388          newADC4Data=1;
     389        }
     390
     391        if (hadc->Instance==ADC5)
     392        {
     393          newADC5Data=1;
    335394        }
    336395 }

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

    r23 r24  
    183183        }
    184184       
    185         uint32_t fixedDelayInBitDurations = (FAST_BAUDRATE_INTERFRAME_DELAY_us * baudrate) / 1000000UL + 1UL;
    186 //      HAL_UART_EnableReceiverTimeout( usart);
    187 //      HAL_UART_ReceiverTimeout_Config(usart,  fixedDelayInBitDurations);
    188 
    189     if(HAL_UARTEx_ReceiveToIdle_DMA(mb_data->uart, mb_data->rx_buffer, RXBUFFERSIZE) != HAL_OK)
     185       
     186        HAL_UART_EnableReceiverTimeout( usart);
     187        HAL_UART_ReceiverTimeout_Config(usart,  3.5 * nrOfBitsPerChar);
     188        SET_BIT(usart->Instance->CR1, USART_CR1_RTOIE);
     189
     190
     191    if(HAL_UART_Receive_DMA(mb_data->uart, mb_data->rx_buffer, RXBUFFERSIZE) != HAL_OK)
    190192    {
    191193      printf("uart error \n\r");
    … …  
    202204    modbusData.mb_rx_frame_complete = 1;
    203205    modbusData.setRxLed = false;
    204         modbusData.rx_head= 0;
    205 
     206        modbusData.rx_head = huart->RxXferSize - __HAL_DMA_GET_COUNTER(huart->hdmarx);
     207       
    206208
    207209  if (huart->ErrorCode == HAL_UART_ERROR_RTO)
    208210  {
    209         printf("MB RTO Event! \n\r");
     211
     212        // printf("MB RTO Event! \n\r");
     213        // Kein Fehler, normale Funktion
    210214  }
    211215  if (huart->ErrorCode == HAL_UART_ERROR_FE)
    … …  
    240244
    241245
    242   if(HAL_UARTEx_ReceiveToIdle_DMA(huart, huart->pRxBuffPtr, RXBUFFERSIZE) != HAL_OK)
     246 
     247  if(HAL_UART_Receive_DMA(huart, huart->pRxBuffPtr, RXBUFFERSIZE) != HAL_OK)
    243248   {
    244249     printf("Uart Error bei neustart nach Fehler \n\r");
    … …  
    250255}
    251256
    252 void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
    253 {
    254   //printf("MB rxEvent!RX=%d \n\r",Size);
    255   modbusData.setRxLed = true;
    256 
    257   modbusData.mb_rx_frame_complete = 1;
    258   modbusData.rx_head= Size +1;
    259 
    260   if(HAL_UARTEx_ReceiveToIdle_DMA(huart, huart->pRxBuffPtr, RXBUFFERSIZE) != HAL_OK)
    261    {
    262      printf("uart error \n\r");
    263   //   while(1)
    264   //   {
    265   //   }     
    266    }   
    267  
    268 
    269 }
     257//void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
     258//{
     259//  //printf("MB rxEvent!RX=%d \n\r",Size);
     260//  modbusData.setRxLed = true;
     261
     262//  modbusData.mb_rx_frame_complete = 1;
     263//  modbusData.rx_head= Size +1;
     264
     265//  if(HAL_UART_Receive_DMA(huart, huart->pRxBuffPtr, RXBUFFERSIZE) != HAL_OK)
     266//   {
     267//     printf("uart error \n\r");
     268//  //   while(1)
     269//  //   {
     270//  //   }     
     271//   }   
     272 
     273
     274//}
    270275
    271276void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)

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

    r20 r24  
    3838void SHUNT_TEMPERATURE_Exec(int32_t adcval)
    3939{
    40   int32_t temp;
     40  double temp;
    4141
    4242
    4343  //Umrechnung Spannung in mV
    44   temp =  (adcval * 3300 ) / 65536;
     44  temp =  (adcval * VREF ) / 65536.0;
    4545
    46   //Umrechnung in °C mit PT 1000 Sensor
    47 //  temp = temp - 747;
    48 //  temp = temp * 70.406;
    4946
    5047  //Umrechnung in °C mit LM61 Sensor
    5148  temp = temp - 600;
    52   temp = temp * 100;
     49  temp = temp / 10;
    5350
    5451  //2Nackommastellen
    5552  //milli grad in grad * 100 /festkomma
    56   sys_data.s.values.shuntTemperature = temp / 10;
     53  sys_data.s.values.shuntTemperature = temp * 100;
    5754
    5855

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

    r20 r24  
    1717
    1818//      --- LOKALE DEFINES - bitte hier dokumentieren --------------------------------
    19 
    20 #define SHUNT_VOLTAGE_DIVIDER       6
     19#define ADC_RESOLUTION                                            32768 //65536/2 da im differential mode
     20#define ADC_OFFSET                                                        32768
     21#define SHUNT_VOLTAGE_DIVIDER                             6
    2122//      --- LOKALE TYPE DEFS - bitte hier dokumentieren-------------------------------
    2223
    … …  
    4445void SHUNT_VOLTAGE_Exec(int32_t newval)
    4546{
    46    static unsigned long avgsum = 0;
    47    uint32_t avgval;
    48    // Filterlängen in 2er-Potenzen --> Compiler optimiert
    49    //avgsum -= avgsum/SHUNT_FILTER;
    50    //avgsum += newval;
    51    //avgval = avgsum / SHUNT_FILTER;
    52 
    53    sys_data.s.values.shuntVoltage =  (newval * (uint64_t)sys_data.s.values.realVdd * SHUNT_VOLTAGE_DIVIDER ) / 65536;
     47   sys_data.s.values.shuntVoltage =  ((newval-ADC_OFFSET) * VREF * SHUNT_VOLTAGE_DIVIDER ) / ADC_RESOLUTION;
    5448
    5549}
Note: See TracChangeset for help on using the changeset viewer.