// Инициализация прерывания с приоритетом 6
  HAL_NVIC_SetPriority(CEC_IRQn, 6, 0);
  HAL_NVIC_EnableIRQ(CEC_IRQn);
// Генерация прерывания
HAL_NVIC_SetPendingIRQ(CEC_IRQn);
// Обработчик
void CEC_IRQHandler(void) {
// user code
}

uint32_t eeprom_read(uint32_t offset, uint8_t * buf, uint32_t len);
ifdef STM32H7
uint32_t eeprom_read(uint32_t offset, uint8_t * buf, uint32_t len)
{
  if (diag_isError(ERR_I2C))
    return 0;
  if (eeprom_wait_ready()) {
    HAL_StatusTypeDef status = HAL_I2C_Mem_Read(&I2C_MEM_HANDLE, I2C_MEM_DEV_ADDR, offset, I2C_MEMADD_SIZE_16BIT, buf, len, I2C_MEM_TIMEOUT_MS);
    if (status == HAL_OK)
      return len;
  }
  diag_setError(ERR_I2C, true);
  return 0;
}
#endif
#ifdef _WIN32
static FILE *fpEeprom = NULL;
#define EMUL_EEPROM_FILE "eeprom.bin"
void checkAndCreateEpromFile() {
  if (fpEeprom == NULL) {
    fopen_s(&fpEeprom, EMUL_EEPROM_FILE, "rb+");
    if (fpEeprom == NULL)
      fopen_s(&fpEeprom, EMUL_EEPROM_FILE, "wb+");
    fseek(fpEeprom, EEPROM_SIZE, SEEK_SET);
    fputc('\0', fpEeprom);
    fflush(fpEeprom);
  }
}
uint32_t eeprom_read(uint32_t offset, uint8_t * buf, uint32_t len)
{
  checkAndCreateEpromFile();
  fseek(fpEeprom, offset, SEEK_SET);
  return (uint32_t)fread(buf, len, 1, fpEeprom);
}
#endif

#define ARCHIVER_HASH_BITS (12)
uint8_t __RAM_288K archiver_hash_table[sizeof(uzlib_hash_entry_t) * (1 << ARCHIVER_HASH_BITS)];
bool archive(const uint8_t* src, uint32_t src_len, uint8_t* dst, uint32_t dst_len, uint32_t *archive_len)
{
  struct uzlib_comp comp = { 0 };
  comp.dict_size = 32768;
  comp.hash_bits = ARCHIVER_HASH_BITS;
  comp.hash_table = (uzlib_hash_entry_t*)&archiver_hash_table[0];
  memset((void*)comp.hash_table, 0, sizeof(archiver_hash_table));
  comp.out.outbuf = &dst[10]; // skip header 10 bytes
  comp.out.outsize = dst_len - 10 - 8; // skip header 10 bytes and tail(crc+len) 8 bytes
  comp.out.is_overflow = false;
  zlib_start_block(&comp.out);
  uzlib_compress(&comp, src, src_len);
  zlib_finish_block(&comp.out);
  if (comp.out.is_overflow)
    comp.out.outlen = 0;
  dst[0] = 0x1f;
  dst[1] = 0x8b;
  dst[2] = 0x08;
  dst[3] = 0x00; // FLG
  // mtime
  dst[4] =
    dst[5] =
    dst[6] =
    dst[7] = 0;
  dst[8] = 0x04; // XFL
  dst[9] = 0x03; // OS
  unsigned crc = ~uzlib_crc32(src, src_len, ~0);
  memcpy(&dst[10 + comp.out.outlen], &crc, sizeof(crc));
  memcpy(&dst[14 + comp.out.outlen], &src_len, sizeof(src_len));
  *archive_len = 18 + comp.out.outlen;
  if (comp.out.is_overflow)
    return false;
  return true;
}

// byte[] res; // сжатые данные
                        using (var msOut = new MemoryStream())
                        using (var ms = new MemoryStream(res))
                        using (var gzip = new GZipStream(ms, CompressionMode.Decompress))
                        {
                            int chunk = 4096;
                            var buffer = new byte[chunk];
                            int read;
                            do
                            {
                                read = gzip.Read(buffer, 0, chunk);
                                msOut.Write(buffer, 0, read);
                            } while (read == chunk);
                            //msOut.ToArray();// обработать распакованный массив данных
                        }

enum {
  IVA_KEY_MASK_NONE,
  IVA_KEY_MASK_ENTER = 0x1,
  IVA_KEY_MASK_ANY   = IVA_KEY_MASK_ENTER,
}IVA_KEY;
uint8_t keyboard_isKeyDown(uint8_t keyMask) {
  return ((keyMask & keyStatesMask) == keyMask);
}

enum {
  IVA_KEY_MASK_NONE  = 0,
  IVA_KEY_MASK_ENTER = 0x01,
  IVA_KEY_MASK_LEFT  = 0x02,
  IVA_KEY_MASK_RIGHT = 0x04,
  IVA_KEY_MASK_UP    = 0x08,
  IVA_KEY_MASK_DOWN  = 0x10,
  IVA_KEY_MASK_ANY   = IVA_KEY_MASK_ENTER | IVA_KEY_MASK_LEFT | IVA_KEY_MASK_RIGHT | IVA_KEY_MASK_UP | IVA_KEY_MASK_DOWN,
}IVA_KEY;

// сброс данных из кэша в озу перед записью их в QSPI/DMA
SCB_CleanDCache_by_Addr((uint32_t*)(((uint32_t)&data[0]) & 0xFFFFFFE0), dataSize + 32);
// Обновление данных от ADC/DMA в кэше перед обращением из CPU
SCB_InvalidateDCache_by_Addr((uint32_t*)&s_pAlignedAdcBuffer[0], sizeof(s_pAlignedAdcBuffer));

// Нужно запомнить параметры калибровки и выставлять их при включении
HAL_ADCEx_Calibration_SetValue (&hadc1, ADC_SINGLE_ENDED, myCalibrationFactor[0]);
HAL_ADCEx_Calibration_SetValue (&hadc1, ADC_DIFFERENTIAL_ENDED, myCalibrationFactor[1]);
HAL_ADCEx_LinearCalibration_SetValue (&hadc1, &myLinearCalib_Buffer[0]);

---    if (((isrflags & USART_ISR_ORE) != 0U)
---        && (((cr1its & USART_CR1_RXNEIE_RXFNEIE) != 0U) ||
---            ((cr3its & (USART_CR3_RXFTIE | USART_CR3_EIE)) != 0U)))
+++    if ((isrflags & USART_ISR_ORE) != 0U)
    {
      __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);

float f_value;
  uint16_t registerValue;
  // Вместо реальных данных в registerValue оказывался 0
  //registerValue = ((uint16_t*)&f_value)[(offsetInMaximeterData -
  //  offsetof(mbreg_Maximeter, primaryValue)) / 2];
  // То же самое через memcpy работат корректно
    memcpy(& registerValue, ((uint16_t*)&f_value) + (offsetInMaximeterData -
        offsetof(mbreg_Maximeter, primaryValue)) / 2, sizeof(uint16_t));

//debug.h
#define USE_DEBUG_POINTS
#ifdef USE_DEBUG_POINTS
//инструмент для поиска места хардфолтов SET_DEBUG_POINT1(__LINE__)
void SET_DEBUG_POINT1(uint32_t val);
void SET_DEBUG_POINT2(uint32_t val);
#else
#define SET_DEBUG_POINT1(...)
#define SET_DEBUG_POINT2(...)
#endif
//debug.c
#ifdef USE_DEBUG_POINTS
volatile uint32_t dbg_point1 = 0;
volatile uint32_t dbg_point2 = 0;
void SET_DEBUG_POINT1(uint32_t val) {
  dbg_point1 = val;
}
void SET_DEBUG_POINT2(uint32_t val) {
  dbg_point2 = val;
}
#endif
// В нескольких местах в коде:
SET_DEBUG_POINT1(__line__);