всё работает

+экранчик

Core/UKSI/uksi_calc_res.c

@@ -60,7 +60,7 @@ float ADC_Calc(ADC_t *adc)
     return 0;
   ADC_Coefs_t *coefs  = &adc->Coefs;
   
-  int16_t rawval = (int16_t)HAL_ADC_GetValue(adc->hadc);
+  int16_t rawval = HAL_ADC_GetValue(adc->hadc);
   
   
   rawval = Filter_Process(&adc->mdn, rawval);
@@ -83,18 +83,22 @@ HAL_StatusTypeDef UKSI_Calc_Init(UKSI_Calc_t *calc, ADC_HandleTypeDef *hadc)
     return HAL_ERROR;
   
   calc->adc.hadc = hadc;
-  ADC_ConfigCoef(&calc->adc, 0, 1.411, 1860, 14);
+//  ADC_ConfigCoef(&calc->adc, 0, 1.259, 1639, 14);
+  ADC_ConfigCoef(&calc->adc, 0, 0.529, 703, 14);
   ADC_ConfigFilter(&calc->adc, 10, 50000);
   
   calc->RMeasOhm = 35060;
   calc->RLimitOhm = 1.5e6;
-  calc->DCVoltage = 63;
+  calc->DCVoltage = 31.58;//60;
   
   foster_init(&calc->adc.foster, 3000.0f);
   foster_set_mse(&calc->adc.foster, 0.001f); /* Подберите под ваши значения напряжения */
   
   HAL_ADCEx_Calibration_Start(hadc, ADC_SINGLE_ENDED);
   
+  calc->IsoOhm = 100e6;
+  calc->IsoMOhm = calc->IsoOhm / 1000000.0f;
+  
   return HAL_ADC_Start(hadc);
 }
 
@@ -113,9 +117,13 @@ float UKSI_Calc_Isolation(UKSI_Calc_t *calc)
   
   if(Filter_isDataReady(&calc->adc.avg))
   {
+    /* Расчет тока */
+    float current = voltage / calc->RMeasOhm;
+    calc->IsoCurrentuA = current * 1000000.0f;
+    
     /* Проверка стабильности напряжения */
     foster_add_sample(&calc->adc.foster, voltage);
-    
+       
     if(foster_is_ready(&calc->adc.foster)) {
       uint8_t stability = foster_check(&calc->adc.foster);
       calc->adc.is_stable = stability;
@@ -126,14 +134,12 @@ float UKSI_Calc_Isolation(UKSI_Calc_t *calc)
       }
     }
     
-    /* Расчет изоляции */
-    float current = voltage / calc->RMeasOhm;
+    /* Расчет изоляции */    
     float Rtotal = calc->DCVoltage / current;
     float Riso = Rtotal - (calc->RMeasOhm + calc->RLimitOhm);
     
     calc->IsoOhm = Riso;
     calc->IsoMOhm = Riso / 1000000.0f;
-    calc->IsoCurrentuA = current * 1000000.0f;
     
   }
   return calc->IsoOhm;

Core/UKSI/uksi_main.c

@@ -1,37 +1,49 @@
 #include "uksi_main.h"
+#include "uksi_oled.h"
 #include "adc.h"
 #include "tim.h"
 UKSI_Calc_t uksi_calc;
 UKSI_DC_t uksi_dc;
-float iso_result;
+float iso_result = 100;
 int dbg_dc = 0;
-int dbg_dc_delay = 5000;
+int dc_min_period = 5000;
+int pause_period = 5000;
+int measure_period = 2500;
 void UKSI_Init()
 {
   DC_Init(&uksi_dc, &htim1, TIM_OCMODE_INACTIVE, TIM_OCMODE_ACTIVE);
   UKSI_Calc_Init(&uksi_calc, &hadc1);
+	oled_init();
 }
 
 
 
 void UKSI_prewhile()
 {
+  iso_result = uksi_calc.IsoOhm;
 }
 
 
 void UKSI_while()
 {
+  static uint32_t prev_oled_tick = 0;
   static uint32_t prev_dc_tick = 0;
   static uint32_t start_measure_tick = 0;
   float curr_iso = 0;
   DC_Enable(&uksi_dc, dbg_dc);
   
+  if(uwTick - prev_oled_tick > 1000)
+  {
+    prev_oled_tick = uwTick;
+    UKSI_Print(iso_result/1000000, dbg_dc, uksi_calc.adc.Voltage, uksi_calc.IsoCurrentuA);
+  }
+  
   if(dbg_dc)
   {
     curr_iso = UKSI_Calc_Isolation(&uksi_calc);
-    if(uwTick - prev_dc_tick > dbg_dc_delay) // подаем импульс минимум на секунду
+    if(uwTick - prev_dc_tick > dc_min_period) // подаем импульс на минимальный период
     {
-      if(!foster_check(&uksi_calc.adc.foster)) // если стабильный уровень найден - отключаем на секунду источник
+      if(!foster_check(&uksi_calc.adc.foster)) // если стабильный уровень найден
       {
         if(start_measure_tick == 0)
         {
@@ -39,7 +51,7 @@ void UKSI_while()
         }
         else
         {
-          if(uwTick - start_measure_tick > dbg_dc_delay)
+          if(uwTick - start_measure_tick > measure_period)
           {
             dbg_dc = 0;
             start_measure_tick = 0;
@@ -48,11 +60,18 @@ void UKSI_while()
           }
         }
       }
+      else if(curr_iso > 10000000)
+      {
+        dbg_dc = 0;
+        start_measure_tick = 0;
+        prev_dc_tick = uwTick;
+        iso_result = curr_iso;
+      }
     }
   }
   else
   {
-    if(uwTick - prev_dc_tick > dbg_dc_delay) // подаем импульс минимум на секунду
+    if(uwTick - prev_dc_tick > pause_period) // ждем паузу перед новой подачей импульса
     {
       dbg_dc = 1;
       prev_dc_tick = uwTick;

Core/UKSI/uksi_oled.c

@@ -0,0 +1,85 @@
+#include "uksi_oled.h"
+
+void UKSI_Print(float Iso, uint8_t DCState, float Voltage, float Current_uA)
+{
+  int second_layer = 22;
+    // Очищаем буфер
+    GFX_Clean_Buffer_Frame(oled_buf);
+    
+    // 1. Сопротивление изоляции - крупно сверху
+    char iso_str[20];
+    
+    // Для STM32 sprintf не поддерживает %f, используем dtostrf или ручное форматирование
+    if (Iso >= 100.0f) {
+        sprintf(iso_str, "OL MOhm");
+    } else if (Iso >= 1.0f) {
+        int int_part = (int)Iso;
+        int dec_part = (int)((Iso - int_part) * 100);
+        sprintf(iso_str, "%d.%02d MOhm", int_part, dec_part);
+    } else if (Iso >= 0.001f) {
+        float kOhm = Iso * 1000.0f;
+        int int_part = (int)kOhm;
+        sprintf(iso_str, "%d kOhm", int_part);
+    } else {
+        float Ohm = Iso * 1000000.0f;
+        int int_part = (int)Ohm;
+        sprintf(iso_str, "%d Ohm", int_part);
+    }
+    
+    // Отображаем сопротивление
+    GFX_Output_String(oled_buf, 10, 2, iso_str, GFX_FONT_TAHOMA_15, 1, 0);
+    
+    
+    // 2. Состояние DC
+    uint8_t x = 105;   // позиция импульса
+    uint8_t y = 14;   // нижний уровень
+    uint8_t h = 8;    // высота импульса
+    uint8_t wl = 2;   // длина нижнего уровня
+    uint8_t wh = 9;   // ширина верхнего уровня
+    if (DCState)
+    {
+        // _|
+        __GFX_Draw_Line(oled_buf, x, y, x + wl, y, 1);
+        __GFX_Draw_Line(oled_buf, x + wl, y, x + wl, y - h, 1);
+
+        // ─ верх
+        __GFX_Draw_Line(oled_buf, x + wl, y - h, x + wl + wh, y - h, 1);
+
+        // |_ 
+        __GFX_Draw_Line(oled_buf, x + wl + wh, y - h, x + wl + wh, y, 1);
+        __GFX_Draw_Line(oled_buf, x + wl + wh, y, x + wl*2 + wh, y, 1);
+    }
+    else
+    {
+        // просто __
+        __GFX_Draw_Line(oled_buf, x, y, x + wl*2 + wh, y, 1);
+    }
+    
+    // 3. Напряжение (0-2В)
+    char volt_str[16];
+    int volt_int = (int)(Voltage * 1000); // милливольты
+    sprintf(volt_str, "U: %d.%03dV", volt_int / 1000, volt_int % 1000);
+    GFX_Output_String(oled_buf, 10, 22, volt_str, GFX_FONT_TAHOMA_8, 1, 0);
+    
+    // 4. Ток (уже в мкА)
+    char curr_str[16];
+    int curr_int = (int)Current_uA;
+    
+    if (Current_uA >= 1000.0f) {
+        sprintf(curr_str, "I: %duA", curr_int);
+    } else if (Current_uA >= 100.0f) {
+        int dec_part = (int)((Current_uA - curr_int) * 1);
+        sprintf(curr_str, "I: %duA", curr_int);
+    } else if (Current_uA >= 10.0f) {
+        int dec_part = (int)((Current_uA - curr_int) * 10);
+        sprintf(curr_str, "I: %d.%01duA", curr_int, dec_part);
+    } else {
+        int dec_part = (int)((Current_uA - curr_int) * 100);
+        sprintf(curr_str, "I: %d.%02duA", curr_int, dec_part);
+    }
+    
+    GFX_Output_String(oled_buf, 72, 22, curr_str, GFX_FONT_TAHOMA_8, 1, 0);
+    
+    // 6. Обновляем дисплей
+    oled_refresh();
+}

Core/UKSI/uksi_oled.h

@@ -0,0 +1,9 @@
+
+#ifndef _UKSI_OLED_H
+#define _UKSI_OLED_H
+
+#include "gfx_lib.h"
+#include "oled.h"
+
+void UKSI_Print(float Iso, uint8_t DCState, float Voltage, float Current);
+#endif //_UKSI_OLED_H