//Здесь идут строки созданные CubeMT
/**
  ******************************************************************************
  * File Name          : main.c
  * Description        : Main program body
  ******************************************************************************
  ** This notice applies to any and all portions of this file
  * that are not between comment pairs USER CODE BEGIN and
  * USER CODE END. Other portions of this file, whether
  * inserted by the user or by software development tools
  * are owned by their respective copyright owners.
  *
  * COPYRIGHT(c) 2024 STMicroelectronics
  ******************************************************************************
  */

/*
  *В этом проекте изучаем работу с I2C, для обмена данными с дальномером TF-Luna.
  *В качестве микроконтроллера используется макетная плата STM32F303_Discovery kit с микроконтроллером STM32F303VCT6
  *В этом варианте, в качестве интерфейса будет использован канал I2C1 с выводами PB6 I2C1_SCL pin92  и PB7 I2C1_SDA pin93
  *На макетной плате дискавери они будут подключены на P2 pin21 и P2 pin22, соответственно.
  *Питание дальномера +5 В от дискавери.
  *Дополнительно установить подтягивающие резисторы 4,7 кОм одключённые к P1 pin1 (+3,3 В) с одной стороны и к P2 pin22 и pin23 с другой стороны (каждый резистор к своему выводу).
  *Можно поэкспериментировать с подтягиванием на +5 В. Вместо P1 pin1 подключить  к P2 pin1 или pin2, но резисторы заменить на 10 кОм. Землю брать с P2 pin49 или pin50.
  *На луне они будут подключены к pin3 (I2C1_SCL) и pin2 (I2C1_SDA). Питание на pin1  земля на pin4. Можно попробывать питание +5 В, а сигналы +3,3 В (или всё 5 В).
 */

/* Includes ----------*/
#include "main.h"
#include "stm32f3xx_hal.h"


/* Define to prevent recursive inclusion ----------*/

/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private variables ----------*/
I2C_HandleTypeDef hi2c1;
DMA_HandleTypeDef hdma_i2c1_tx;
DMA_HandleTypeDef hdma_i2c1_rx;

/* Константы для работы с дальномером по I2C---------------------------------*/
#define I2C_ADDRESS  0x10      //Определяем адрес переферии (слэйва) с которой будем работать по I2C (см. даташит на дальномер TF-Luna)

#define  NumEltBufLunaData   2          //Задал размер буфера (в МК) в который будут помещаться данные (2 байта), полученные от ведомого устройства.
uint8_t bufLunaData[NumEltBufLunaData] = {0x00,}; //Буфер (в МК) (массив - адрес 0-го эл-та, т.е. указатель) в котором будут храниться данные (2 байта), полученные от ведомого устройства.

#define sizeRegDist 2                   //Задал размер буфера (в луне), откуда берутся данные замера расстояния
uint16_t RegDist[sizeRegDist] = {0x00, 0x01};    //Буфер с адресами регистров луны (см. даташит), в которых хранятся данные замера расстояния (соответственно Lo и Hi)

//uint8_t regDistLo = 0x00;       //Адрес регистра (в луне), где хранятся данные расстояния (младший разряд). Присваиваем в ф-ях, по мере надобности.
//uint8_t regDistHi = 0x01;       //Адрес регистра (в луне), где хранятся данные расстояния (старший разряд). Присваиваем в ф-ях, по мере надобности.


/* USER CODE BEGIN PV */
/* Private variables ----------*/
/* USER CODE END PV */

/* Private function prototypes ----------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_I2C1_Init(void);
static void MX_NVIC_Init(void);
HAL_StatusTypeDef HAL_Init(void);


/* USER CODE BEGIN PFP */
/* Private function prototypes ----------*/

/* USER CODE END PFP */

/* USER CODE BEGIN 0 */


/*Объявление функции чтения данных с дальномера в массив МК-------------------*/

//Обращение к дальномеру, как к памяти (по регистрам)
void bufLunaMemRead(uint16_t, uint16_t*, uint16_t, uint8_t*, uint8_t);
//Аргументы:
//адрес дальномера, как слэйва в I2C
//адрес массива с адресами регистров дальномера, откуда берутся данные замера расстояния
//размер массива луны, откуда берутся данные замера расстояния
//массив (адрес 0-го эл-та, т.е. указатель) МК в который передаётся результат замера
//размер массива МК

//Обращение к дадьномеру, как к слэйву
void bufLunaSlaveRead(uint16_t, uint16_t*, uint16_t, uint8_t*, uint8_t);
//Аргументы:
//адрес дальномера, как слэйва в I2C
//адрес массива с адресами регистров дальномера, откуда берутся данные замера расстояния
//размер массива луны, откуда берутся данные замера расстояния
//массив (адрес 0-го эл-та, т.е. указатель) МК в который передаётся результат замера
//размер массива МК


/*Функции для отладки---------------------------------------------------------*/

/*Сделал (объявил) свою ф-ю, чтобы вставлять в код для определения "дошёл ли сюда?"-----*/
void TestLed (uint8_t); //Аргумент: кол-во вспышек.

/*Сделал (объявил) ф-ю, чтобы печатать массив-------------------------------------------*/
void PrintArray(uint8_t*, uint8_t);      //Аргументы: указатель на массив (его адрес) и размер массива (байт).


/* USER CODE END 0 */


int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
 
  /* Configure the system clock */
  SystemClock_Config();
   
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_I2C1_Init();
 
 /* Initialize interrupts */
  MX_NVIC_Init();
 
 
  /* USER CODE BEGIN Init */

  /* USER CODE END Init */
 

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */ 
 
 
  /* USER CODE BEGIN 2 */
 
  /* USER CODE END 2 */
   
/*Запускаем ф-ю получения данных через I2C и DMA------------------------------*/

    if (HAL_I2C_IsDeviceReady(&hi2c1, (I2C_ADDRESS << 1), 1, HAL_MAX_DELAY) == HAL_OK)     //Проверяем есть ли подключение к дальномеру.
    {
      //Если дальномер подключён, то вызываем ф-ю чтения данных с дальномера в массив МК.
     
      //Вызываем ф-ю обращающуюся к дальномеру, как к памяти     
      bufLunaMemRead(I2C_ADDRESS, RegDist, sizeRegDist, bufLunaData, NumEltBufLunaData);
      //Аргументы:
      //I2C_ADDRESS - адрес дальномера, как слэйва в I2C
      //RegDist - адрес массива с адресами регистров дальномера, откуда берутся данные замера расстояния
      //sizeRegDist - размер массива луны, откуда берутся данные замера расстояния
      //bufLunaData - массив (адрес 0-го эл-та, т.е. указатель) МК в который передаётся результат замера
      //NumEltBufLunaData - размер массива МК
     
      //Вызываем ф-ю обращающуюся к дальномеру, как к слэйву
      bufLunaSlaveRead(I2C_ADDRESS, RegDist, sizeRegDist, bufLunaData, NumEltBufLunaData);
      //Аргументы:
      //I2C_ADDRESS - адрес дальномера, как слэйва в I2C
      //RegDist - адрес массива с адресами регистров дальномера, откуда берутся данные замера расстояния
      //sizeRegDist - размер массива луны, откуда берутся данные замера расстояния
      //bufLunaData - массив (адрес 0-го эл-та, т.е. указатель) МК в который передаётся результат замера
      //NumEltBufLunaData - размер массива МК
     
//     PrintArray (bufLunaData, sizeRegDist);     //Распечатываю одномерный массив. Аргументы: указатель на массив (его адрес) и кол-во эл-тов массива.
     
      TestLed (1);        //Если светик моргнул 1 раз, значит я здесь (был).
      HAL_Delay(1000);    //Задержка, чтобы успеть отличить серии из 1-й вспышки.
     
    } else
    {
      TestLed (2);        //Если светик моргнул 2 раза, значит я здесь (был).
      HAL_Delay(1000);    //Задержка, чтобы успеть отличить серии из 2-х вспышек.
    }   //end HAL_I2C_IsDeviceReady
 
       
  /* Infinite loop */
 
   while (1)
  {
  /* USER CODE BEGIN WHILE */
 
    TestLed (4);         //Если светик моргнул 4 раза, значит я здесь (был).
    HAL_Delay(1000);    //Задержка, чтобы успеть отличить серии из 4-х вспышек.

  /* USER CODE END WHILE */
  }     //end while
 
   
  /* USER CODE BEGIN 3 */
 
  /* USER CODE END 3 */

}       //end main
 

/** System Clock Configuration
*/
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct;
  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  RCC_PeriphCLKInitTypeDef PeriphClkInit;

    /**Initializes the CPU, AHB and APB busses clocks
    */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = 16;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Initializes the CPU, AHB and APB busses clocks
    */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_I2C1;
  PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_SYSCLK;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure the Systick interrupt time
    */
  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

    /**Configure the Systick
    */
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  /* SysTick_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}       //end SystemClock_Config

/** NVIC Configuration
*/
static void MX_NVIC_Init(void)
{
  /* RCC_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(RCC_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(RCC_IRQn);
//  /* FPU_IRQn interrupt configuration */
//  HAL_NVIC_SetPriority(FPU_IRQn, 0, 0);         //Добавил 2 строчки из "Ногодрыг1"
//  HAL_NVIC_EnableIRQ(FPU_IRQn);
//  /* DMA1_Channel6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
  /* DMA1_Channel7_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
  /* I2C1_EV_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(I2C1_EV_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(I2C1_EV_IRQn);
  /* I2C1_ER_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(I2C1_ER_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(I2C1_ER_IRQn);
  /* FLASH_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(FLASH_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(FLASH_IRQn);
}       //end NVIC Configuration

/* I2C1 init function */
static void MX_I2C1_Init(void)
{
  hi2c1.Instance = I2C1;
  hi2c1.Init.Timing = 0x2000090E;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure Analogue filter
    */
  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure Digital filter
    */
  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

}       //end MX_I2C1_Init

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{
  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

//  /* DMA interrupt init */    //Закоментил т.к. уже есть в MX_NVIC_Init
//  /* DMA1_Channel6_IRQn interrupt configuration */
//  HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0);
//  HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
//  /* DMA1_Channel7_IRQn interrupt configuration */
//  HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 0, 0);
//  HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);

}       //end MX_DMA_Init

/** Configure pins as
        * Analog
        * Input
        * Output
        * EVENT_OUT
        * EXTI
     PA5   ------> SPI1_SCK
     PA6   ------> SPI1_MISO
     PA7   ------> SPI1_MOSI
     PA11   ------> USB_DM
     PA12   ------> USB_DP
    PB6   -----> I2C1_SCL         //Куб не добавляет (здесь) ноги для I2C. Пришлось самому.
    PB7   -----> I2C1_SDA
*/
static void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOE, CS_I2C_SPI_Pin|LD4_Pin|LD3_Pin|LD5_Pin
                          |LD7_Pin|LD9_Pin|LD10_Pin|LD8_Pin
                          |LD6_Pin, GPIO_PIN_RESET);
 
  HAL_GPIO_WritePin(GPIOB, I2C1_SCL_Pin|I2C1_SDA_Pin, GPIO_PIN_RESET); //Добавил GPIOB и I2C1_SCL_Pin|I2C1_SDA_Pin| для ног I2C

  /*Configure GPIO pins : DRDY_Pin MEMS_INT3_Pin MEMS_INT4_Pin MEMS_INT1_Pin
                           MEMS_INT2_Pin */
  GPIO_InitStruct.Pin = DRDY_Pin|MEMS_INT3_Pin|MEMS_INT4_Pin|MEMS_INT1_Pin
                          |MEMS_INT2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_EVT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /*Configure GPIO pins : CS_I2C_SPI_Pin LD4_Pin LD3_Pin LD5_Pin
                           LD7_Pin LD9_Pin LD10_Pin LD8_Pin
                           LD6_Pin */
  GPIO_InitStruct.Pin = CS_I2C_SPI_Pin|LD4_Pin|LD3_Pin|LD5_Pin
                          |LD7_Pin|LD9_Pin|LD10_Pin|LD8_Pin
                          |LD6_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /*Configure GPIO pin : B1_Pin */
  GPIO_InitStruct.Pin = B1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : SPI1_SCK_Pin SPI1_MISO_Pin SPI1_MISOA7_Pin */
  GPIO_InitStruct.Pin = SPI1_SCK_Pin|SPI1_MISO_Pin|SPI1_MISOA7_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : DM_Pin DP_Pin */
  GPIO_InitStruct.Pin = DM_Pin|DP_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF14_USB;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
  /*Configure GPIO pins : I2C1_SCL_Pin I2C1_SDA_Pin */
  //Думаю здесь надо настроить ноги для I2C. Куб этого (здесь) не сделал
  GPIO_InitStruct.Pin = I2C1_SCL_Pin|I2C1_SDA_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;       //Open Drain???
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF4_I2C1;    //Вставил для I2C
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}       //end MX_GPIO_Init

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @param  None
  * @retval None
  */
void _Error_Handler(char * file, int line)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  while(1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef USE_FULL_ASSERT

/**
   * @brief Reports the name of the source file and the source line number
   * where the assert_param error has occurred.
   * @param file: pointer to the source file name
   * @param line: assert_param error line source number
   * @retval None
   */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */

}

#endif

/*Функции работы с дальномером------------------------------------------------*/

/*Описание функции чтения данных с дальномера в массив МК. Обращаемся к луне, как к памяти----------*/
void bufLunaMemRead(uint16_t i2cAddress, uint16_t *pReg_Dist, uint16_t sizeReg_Dist, uint8_t *pBuf_Luna_Data, uint8_t numEltBufLunaData)
//Аргументы:
//i2cAddress - адрес дальномера, как слэйва в I2C
//*pReg_Dist - адрес (0-го элемента) массива с адресами регистров дальномера, откуда берутся данные замера расстояния
//sizeReg_Dist - размер массива луны, откуда берутся данные замера расстояния
//*pBuf_Luna_Data - массив (адрес 0-го эл-та, т.е. указатель) МК в который передаётся результат замера
//numEltBufLunaData - размер массива МК (кол-во элементов)
{
  uint16_t *regDistLo = &pReg_Dist[0];      //Сделал переменную с адресом 0-го элемента в регистре луны
  uint8_t *pregBufLunaData1 = &bufLunaData[0];  //Сделал указатель на 0-й элемент массива МК
  HAL_I2C_Mem_Read_DMA(&hi2c1, (i2cAddress<<1), *regDistLo, 1, pregBufLunaData1, 1);
  //Обращаюсь к 0-му элементу дальномера по адресу из указателя regDistLo и записываю в 0-й элемент буфера МК .
  uint16_t *regDistHi = &pReg_Dist[1];      //Сделал переменную с адресом 1-го элемента в регистре луны
  uint8_t *pregBufLunaData2 = &bufLunaData[1];  //Сделал указатель на 1-й элемент массива МК
  HAL_I2C_Mem_Read_DMA(&hi2c1, (i2cAddress<<1), *regDistHi, 1, pregBufLunaData2, 1);
  //Обращаюсь к 1-му элементу дальномера по адресу из указателя regDistHi и записываю в 1-й элемент буфера МК .
  PrintArray (pBuf_Luna_Data, numEltBufLunaData);     //ТЭСТ!!!! Распечатываю одномерный массив. Параметры - указатель на массив (его адрес) и кол-во эл-тов массива.
} //end bufLunaMemRead

/*Описание функции чтения данных с дальномера в массив МК. Обращаемся к луне, как к слэйву-------- */
  void bufLunaSlaveRead(uint16_t i2cAddress, uint16_t *pReg_Dist, uint16_t sizeReg_Dist, uint8_t *pBuf_Luna_Data, uint8_t numEltBufLunaData)
//Аргументы:
//i2cAddress - адрес дальномера, как слэйва в I2C
//*pReg_Dist - адрес (0-го элемента) массива с адресами регистров дальномера, откуда берутся данные замера расстояния
//sizeReg_Dist - размер массива луны, откуда берутся данные замера расстояния
//*pBuf_Luna_Data - массив (адрес 0-го эл-та, т.е. указатель) МК в который передаётся результат замера
//numEltBufLunaData - размер массива МК (кол-во элементов)
  {
     HAL_I2C_Master_Receive_DMA(&hi2c1, (i2cAddress << 1), pBuf_Luna_Data, numEltBufLunaData);  //Принимаем данные от слэйва
    //Аргументы:
    //hi2c1 - структура конфигурации, которая содержит настройки параметров I2C (определена в файле i2c.c)
    //i2cAddress - адрес дальномера, как слэйва в I2C
    //pBuf_Luna_Data - массив (адрес 0-го эл-та, т.е. указатель) МК в который передаётся результат замера
    //numEltBufLunaData - размер массива МК (кол-во элементов)
    PrintArray (pBuf_Luna_Data, numEltBufLunaData);     //ТЭСТ!!!! Распечатываю одномерный массив. Параметры - указатель на массив (его адрес) и кол-во эл-тов массива.
//    TestLed (5);        //ТЭСТ!!!! Если светик моргнул 5 раз, значит я здесь (был).
//    HAL_Delay(1000);    //ТЭСТ!!!! Задержка, чтобы успеть отличить серии из 5-и вспышек.
  } //end bufLunaSlaveRead



/*Отладочные функции----------------------------------------------------------*/
 
/*Сделал ф-ю, чтобы вставлять в код для определения "дошёл ли сюда?".---------*/
void TestLed (uint8_t repeat)   //Аргумент ф-ии: ко-во вспышек светика.
{
  HAL_GPIO_WritePin(LD7_GPIO_Port, LD7_Pin, GPIO_PIN_RESET);   //Погасили светик, если светился.
  uint8_t i = repeat*2-1;       //Вычисляем количество циклов включения/выключения (начиная с 0-го)
  while (i > 0)                 //Мигаем сколько нужно
  {
    i--;
    HAL_GPIO_TogglePin(LD7_GPIO_Port, LD7_Pin);         //ф-я перемены активности светодиода (зелёный LD7, порт PE11).
    HAL_Delay(200);                                     //Задержка, чтобы успеть заметить изменения.
  }
  HAL_GPIO_WritePin(LD7_GPIO_Port, LD7_Pin, GPIO_PIN_RESET);   //Погасили светик, если светился. 
} //endTestLed

/*Создал ф-ю печати одномерного массива. Аргументы: указатель на массив (адрес) и размер массива-------*/
  void PrintArray(uint8_t *Massive, uint8_t NumEltMassive)
  {
    uint8_t i=0;
    while(i<NumEltMassive)            //Проходим по элементам массива.
    {
      printf ("element[%u]= %u\n", i, Massive[i]);      //Распечатывает элементы массива pname построчно (в десятичном формате).
        i++;
    }
    printf ("\n");                    //Переводит строку.
  } //end PrintArray

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/