engineer4ever 님의 블로그

  /* USER CODE BEGIN 2 */
  ssd1306_Init();
  HAL_Delay(1000);

  ssd1306_SetCursor(0,0);
  ssd1306_WriteString("LINE1", Font_7x10, White);

  ssd1306_SetCursor(0,10);
  ssd1306_WriteString("LINE2", Font_7x10, White);

  ssd1306_SetCursor(0,20);
  ssd1306_WriteString("LINE3", Font_7x10, White);

  ssd1306_SetCursor(0,30);
  ssd1306_WriteString("LINE4", Font_7x10, White);

  ssd1306_SetCursor(0,40);
  ssd1306_WriteString("LINE5", Font_7x10, White);

  ssd1306_SetCursor(0,50);
  ssd1306_WriteString("LINE6", Font_7x10, White);

  ssd1306_UpdateScreen();
  /* USER CODE END 2 */

/* Entry Point */
ENTRY(Reset_Handler)

/* Highest address of the user mode stack */
_estack = 0x2000CFFF;    /* end of RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x200;      /* required amount of heap  */
_Min_Stack_Size = 0x9500; /* required amount of stack */

/* Specify the memory areas */
MEMORY
{
RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 48K
FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 256K
}

._user_heap_stack
                0x20002cf4     0x9700 load address 0x080114a0
                0x20002cf4                . = ALIGN (0x4)
                0x20002cf4                PROVIDE (end, .)
                [!provide]                PROVIDE (_end, .)
                0x20002ef4                . = (. + _Min_Heap_Size)
 *fill*         0x20002cf4      0x200 
                0x2000c3f4                . = (. + _Min_Stack_Size)
 *fill*         0x20002ef4     0x9500 
                0x2000c3f4                . = ALIGN (0x4)

uint32_t adc_val[20] = {1, };

LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_1);

LL_DMA_ConfigAddresses(DMA1, LL_DMA_CHANNEL_1,
					  LL_ADC_DMA_GetRegAddr(ADC1, LL_ADC_DMA_REG_REGULAR_DATA),
					  (uint32_t)&adc_val, LL_DMA_DIRECTION_PERIPH_TO_MEMORY);

LL_DMA_SetDataLength(DMA1, LL_DMA_CHANNEL_1, 4);

LL_DMA_EnableIT_TC(DMA1, LL_DMA_CHANNEL_1);
LL_DMA_EnableIT_TE(DMA1, LL_DMA_CHANNEL_1);

LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_1);

LL_ADC_REG_SetDMATransfer(ADC1,LL_ADC_REG_DMA_TRANSFER_UNLIMITED);
LL_ADC_Enable(ADC1);

HAL_GPIO_WritePin (LED_WDT_GPIO_Port, LED_WDT_Pin, GPIO_PIN_RESET);
/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
	LL_ADC_REG_StartConversionSWStart(ADC1);
	printf("%d\n", adc_val[0]);
}

static void MX_ADC1_Init(void)
{

  /* USER CODE BEGIN ADC1_Init 0 */

  /* USER CODE END ADC1_Init 0 */

  LL_ADC_InitTypeDef ADC_InitStruct = {0};
  LL_ADC_CommonInitTypeDef ADC_CommonInitStruct = {0};
  LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};

  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* Peripheral clock enable */
  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC1);

  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA);
  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOC);
  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOB);
  /**ADC1 GPIO Configuration
  PA2   ------> ADC1_IN2
  PC5   ------> ADC1_IN15
  PB0   ------> ADC1_IN8
  PB1   ------> ADC1_IN9
  */
  GPIO_InitStruct.Pin = LL_GPIO_PIN_2;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_5;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
  LL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_0|LL_GPIO_PIN_1;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
  LL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* ADC1 DMA Init */

  /* ADC1 Init */
  LL_DMA_SetDataTransferDirection(DMA1, LL_DMA_CHANNEL_1, LL_DMA_DIRECTION_PERIPH_TO_MEMORY);

  LL_DMA_SetChannelPriorityLevel(DMA1, LL_DMA_CHANNEL_1, LL_DMA_PRIORITY_LOW);

  LL_DMA_SetMode(DMA1, LL_DMA_CHANNEL_1, LL_DMA_MODE_CIRCULAR);

  LL_DMA_SetPeriphIncMode(DMA1, LL_DMA_CHANNEL_1, LL_DMA_PERIPH_NOINCREMENT);

  LL_DMA_SetMemoryIncMode(DMA1, LL_DMA_CHANNEL_1, LL_DMA_MEMORY_INCREMENT);

  LL_DMA_SetPeriphSize(DMA1, LL_DMA_CHANNEL_1, LL_DMA_PDATAALIGN_WORD);

  LL_DMA_SetMemorySize(DMA1, LL_DMA_CHANNEL_1, LL_DMA_MDATAALIGN_WORD);

  /* USER CODE BEGIN ADC1_Init 1 */

  /* USER CODE END ADC1_Init 1 */
  /** Common config
  */
  ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;
  ADC_InitStruct.SequencersScanMode = LL_ADC_SEQ_SCAN_DISABLE;
  LL_ADC_Init(ADC1, &ADC_InitStruct);
  ADC_CommonInitStruct.Multimode = LL_ADC_MULTI_INDEPENDENT;
  LL_ADC_CommonInit(__LL_ADC_COMMON_INSTANCE(ADC1), &ADC_CommonInitStruct);
  ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;
  ADC_REG_InitStruct.SequencerLength = 1;
  ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE;
  ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_SINGLE;
  ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_UNLIMITED;
  LL_ADC_REG_Init(ADC1, &ADC_REG_InitStruct);
  /** Configure Regular Channel
  */
  LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_1, LL_ADC_CHANNEL_15);
  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_15, LL_ADC_SAMPLINGTIME_55CYCLES_5);
  /* USER CODE BEGIN ADC1_Init 2 */

  /* USER CODE END ADC1_Init 2 */

}

void DMA1_Channel1_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel1_IRQn 0 */
	 if( LL_DMA_IsActiveFlag_TC1(DMA1))
	 {
		  LL_DMA_ClearFlag_TC1(DMA1);
	 }
	 else if(LL_DMA_IsActiveFlag_TE1(DMA1))
	 {
	 	 LL_DMA_ClearFlag_TE1(DMA1);
	 }
  /* USER CODE END DMA1_Channel1_IRQn 0 */

  /* USER CODE BEGIN DMA1_Channel1_IRQn 1 */

  /* USER CODE END DMA1_Channel1_IRQn 1 */
}

   while (1)
   {
	  GPIOB->ODR |= GPIO_PIN_12;
	  GPIOB->ODR &= ~GPIO_PIN_12;
   }

   while (1)
   {
	  GPIOB->ODR |= GPIO_PIN_12;
	  delay_count << 1;
	  GPIOB->ODR &= ~GPIO_PIN_12;
	  delay_count << 1;
   }

   while (1)
   {
	  GPIOB->BSRR = GPIO_PIN_12;
	  delay_count << 1;
	  GPIOB->BRR = GPIO_PIN_12;
	  delay_count << 1;
   }

/* USER CODE BEGIN 0 */
uint16_t adc_read[3] = {1, };

/* USER CODE BEGIN 2 */
HAL_ADC_Start_DMA(&hadc1,(uint16_t*)&(adc_read[0]),3);

/* USER CODE END 2 */

void DMA1_Channel1_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel1_IRQn 0 */

  /* USER CODE END DMA1_Channel1_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_adc1);
  /* USER CODE BEGIN DMA1_Channel1_IRQn 1 */
	if(adc_flag == 1)
	{
		adc_read1[adc_index] = adc_read[0];
		adc_read2[adc_index] = adc_read[1];
		adc_read3[adc_index++] = adc_read[2];
		if(adc_index > 999) {
			adc_flag = 0;
		}
	}
  /* USER CODE END DMA1_Channel1_IRQn 1 */
}

/* Transfer Complete Interrupt management ***********************************/
else if (((flag_it & (DMA_FLAG_TC1 << hdma->ChannelIndex)) != RESET) && ((source_it & DMA_IT_TC) != RESET))
{
	if(adc_flag == 1)
	{
		adc_read1[adc_index] = adc_read[0];
		adc_read2[adc_index] = adc_read[1];
		adc_read3[adc_index++] = adc_read[2];
		if(adc_index > 999) {
			adc_flag = 0;
		}
	}

int main(void)
{
  /* USER CODE BEGIN 1 */
	HAL_StatusTypeDef status = HAL_ERROR;

	int i = 0;

	uint16_t FM24V02_addr = 0xA0;

	uint8_t tx_buffer[65] = {};
	uint8_t rx_buffer[65] = {};

  /* USER CODE END 1 */

  /* USER CODE BEGIN 2 */
	tx_buffer[0] = 0x12;

	// Byte Write
	status = HAL_I2C_Mem_Write(&hi2c1, FM24V02_addr, 0x0001, 2, tx_buffer, 1, 1000);
	if(status != HAL_OK)
	{
		printf("I2C Byte Write error\n");
	}

	// Byte Read
	status = HAL_I2C_Mem_Read(&hi2c1, FM24V02_addr, 0x0001, 2, rx_buffer, 1, 1000);
	if(status == HAL_OK)
	{
		printf("Byte Read : %d\n", rx_buffer[0]);
	}
	else
	{
		printf("I2C Byte Read error\n");
	}

	// Page Write
	for (i = 0; i < 64; i++)
	{
		tx_buffer[i] = i;
	}
	status = HAL_I2C_Mem_Write(&hi2c1, FM24V02_addr, 0x0100, 2, tx_buffer, 64, 1000);
	if(status != HAL_OK)
	{
		printf("I2C Page Write error\n");
	}

	// Page Read
	status = HAL_I2C_Mem_Read(&hi2c1, FM24V02_addr, 0x0100, 2, rx_buffer, 64, 1000);
	if(status == HAL_OK)
	{
		for (i = 0; i < 64; i++)
		{
			printf("Page Read(%d) : %d\n", i, rx_buffer[i]);
		}
	}
	else
	{
		printf("I2C Page Read error\n");
	}

  /* USER CODE END 2 */

uint16_t FM24V02_addr = 0xA0;
uint8_t reg_addr = 0x0001;

uint8_t data_8bit = 0;
uint16_t data_16bit[65] = {};

void eeprom_i2c_write(uint16_t size)
{
	HAL_StatusTypeDef status = HAL_ERROR;
	reg_addr = 0x0001;

	for(int i = 0; i< size; i++)
    {
		data_8bit = (uint8_t)(data_16bit[i] >> 8);
		status = HAL_I2C_Mem_Write(&hi2c1, FM24V02_addr, reg_addr+(i*2), 2, &data_8bit, 1, 1000);
		HAL_Delay(10);

		data_8bit = (uint8_t)(data_16bit[i] & 0xff);
		status = HAL_I2C_Mem_Write(&hi2c1, FM24V02_addr, reg_addr+(i*2)+1, 2, &data_8bit, 1, 1000);

		if(status != HAL_OK)
		{
		    printf("EEPROM Byte Write error : %d\n", status);
		}
    }
}

void eeprom_i2c_read(uint16_t size)
{
	HAL_StatusTypeDef status = HAL_ERROR;
	reg_addr = 0x0001;

    for(int i = 0; i< size; i++)
    {
    	status = HAL_I2C_Mem_Read(&hi2c1, FM24V02_addr, reg_addr+(i*2), 2, &data_8bit , 1, 1000);
    	data_16bit[i] = data_8bit << 8;
        HAL_Delay(10);

        status = HAL_I2C_Mem_Read(&hi2c1, FM24V02_addr, reg_addr+(i*2)+1, 2, &data_8bit , 1, 1000);
        data_16bit[i] += data_8bit;

		if(status == HAL_OK)
		{
			printf("EEPROM Page Read(%d) : %d\n", i, data_16bit[i]);
		}
		else
		{
			printf("EEPROM Byte Read error\n");
		}
    }
}

extern uint32_t uwTick;

void SysTick_Handler(void)
{
	/* USER CODE BEGIN SysTick_IRQn 0 */

	/* USER CODE END SysTick_IRQn 0 */
	HAL_IncTick();
	/* USER CODE BEGIN SysTick_IRQn 1 */
	if ( uwTick % 500 == 0 )
	{
		HAL_GPIO_TogglePin (LED_WDT_GPIO_Port, LED_WDT_Pin);

	}
	/* USER CODE END SysTick_IRQn 1 */
}

void SysTick_Handler(void)
{
	/* USER CODE BEGIN SysTick_IRQn 0 */

	/* USER CODE END SysTick_IRQn 0 */
	HAL_IncTick();
	/* USER CODE BEGIN SysTick_IRQn 1 */
	HAL_SYSTICK_IRQHandler();
	/* USER CODE END SysTick_IRQn 1 */
}

void HAL_SYSTICK_IRQHandler(void)
{
	HAL_SYSTICK_Callback();
}

__weak void HAL_SYSTICK_Callback(void)
{
  /* NOTE : This function Should not be modified, when the callback is needed,
            the HAL_SYSTICK_Callback could be implemented in the user file
   */
}

extern uint32_t uwTick;

void HAL_SYSTICK_Callback(void)
{
	if ( uwTick % 500 == 0) {
		HAL_GPIO_TogglePin (LED_WDT_GPIO_Port, LED_WDT_Pin);
	}
}

/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_RTC_Init();
MX_USART1_UART_Init();
MX_TIM6_Init();
MX_TIM7_Init();
/* USER CODE BEGIN 2 */
HAL_ADC_Start_DMA(&hadc1,(uint16_t*)&(adc_val[0]),3);
HAL_TIM_Base_Start_IT (&htim6);
HAL_TIM_Base_Start_IT (&htim7);
HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
/* USER CODE END 2 */